Beispiel #1
0
        private void    CubeMapSamplerSetIndex(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            Probe.Set S = _Pixel.ParentSet;
            byte      C = 0;

            if (S != null && S.SetIndex != -1 && (!m_IsolateSet || S.SetIndex == m_IsolatedSetIndex))
            {
                C = m_IsolateSet ? (byte)255 : (byte)(255 * (1 + S.SetIndex) / m_Probe.m_Sets.Length);
            }
            _R = _G = _B = C;
        }
Beispiel #2
0
        private void    CubeMapSamplerNormal(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
#if ABS_NORMAL
            _R = (byte)Math.Min(255, 255 * Math.Abs(_Pixel.Normal.x));
            _G = (byte)Math.Min(255, 255 * Math.Abs(_Pixel.Normal.y));
            _B = (byte)Math.Min(255, 255 * Math.Abs(_Pixel.Normal.z));
#else
            _R = (byte)Math.Min(255, 127 * (1.0f + _Pixel.Normal.x));
            _G = (byte)Math.Min(255, 127 * (1.0f + _Pixel.Normal.y));
            _B = (byte)Math.Min(255, 127 * (1.0f + _Pixel.Normal.z));
#endif
        }
Beispiel #3
0
        private void    CubeMapSamplerSetAlbedo(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            Probe.Set S = _Pixel.ParentSet;
            if (S == null || S.SetIndex == -1 || (m_IsolateSet && S.SetIndex != m_IsolatedSetIndex))
            {
                _R = _G = _B = 0;
                return;
            }

            _R = (byte)Math.Min(255, 255 * S.Albedo.x);
            _G = (byte)Math.Min(255, 255 * S.Albedo.y);
            _B = (byte)Math.Min(255, 255 * S.Albedo.z);
        }
Beispiel #4
0
        private void    CubeMapSamplerSetDistance(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            Probe.Set S = _Pixel.ParentSet;
            if (S == null || S.SetIndex == -1 || (m_IsolateSet && S.SetIndex != m_IsolatedSetIndex))
            {
                _R = 63;
                _G = 0;
                _B = 63;
                return;
            }

            float Distance2SetCenter = 0.2f * (_Pixel.Position - S.Position).Length;

            byte C = (byte)Math.Min(255, 255 * Distance2SetCenter);

            _R = _G = _B = C;
        }
Beispiel #5
0
        private void    CubeMapSamplerSetSamples(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            Probe.Set S = _Pixel.ParentSet;
            if (S == null || S.SetIndex == -1 || S.EmissiveMatID != -1 || (m_IsolateSet && S.SetIndex != m_IsolatedSetIndex))
            {
                _R = 0;
                _G = 0;
                _B = 0;
                return;
            }

//          float	Distance2SetCenter = 0.2f * (_Pixel.Position - S.Position).Length;
//          byte	C = (byte) Math.Min( 255, 255 * Distance2SetCenter );

            byte C = (byte)(255 * (1 + _Pixel.ParentSetSampleIndex) / S.Samples.Length);

            _R = _G = _B = C;
        }
Beispiel #6
0
        private void    CubeMapSamplerSetNormal(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            Probe.Set S = _Pixel.ParentSet;
            if (S == null || S.SetIndex == -1 || (m_IsolateSet && S.SetIndex != m_IsolatedSetIndex))
            {
                _R = _G = _B = 0;
                return;
            }

#if ABS_NORMAL
            _R = (byte)Math.Min(255, 255 * Math.Abs(S.Normal.x));
            _G = (byte)Math.Min(255, 255 * Math.Abs(S.Normal.y));
            _B = (byte)Math.Min(255, 255 * Math.Abs(S.Normal.z));
#else
            _R = (byte)Math.Min(255, 127 * (1.0f + S.Normal.x));
            _G = (byte)Math.Min(255, 127 * (1.0f + S.Normal.y));
            _B = (byte)Math.Min(255, 127 * (1.0f + S.Normal.z));
#endif
        }
Beispiel #7
0
        private void    CubeMapSamplerSH(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            float3 Dir = _Pixel.View;

            // Dot the SH together
            float3 Color = float3.Zero;

            if (m_IsolateSet)
            {
                float Factor = 1.0f;
                if (m_bShowSHDynamic)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        Color += (float)_Pixel.SHCoeffs[i] * m_Probe.m_Sets[m_IsolatedSetIndex].SH[i];
                    }

                    Factor = m_bNormalizeSH ? 2.0f * m_Probe.m_Sets[m_IsolatedSetIndex].SH[0].Max() : 1.0f;
                }

                if (m_bShowSHEmissive)
                {
                    int EmissiveSetIndex = Math.Min(m_IsolatedSetIndex, m_Probe.m_EmissiveSets.Length - 1);
                    if (EmissiveSetIndex >= 0)
                    {
                        for (int i = 0; i < 9; i++)
                        {
                            Color += (float)_Pixel.SHCoeffs[i] * m_Probe.m_EmissiveSets[EmissiveSetIndex].SH[i];
                        }
                    }

                    Factor = m_bNormalizeSH ? 2.0f * m_Probe.m_EmissiveSets[EmissiveSetIndex].SH[0].Max() : 1.0f;
                }

//				Color *= 100.0f;
                Color *= 1.0f / Factor;
            }
            else
            {
                float Factor = 0.0f;
                if (m_bShowSHStatic)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        Color += (float)_Pixel.SHCoeffs[i] * m_SHStatic[i];
                    }
                    Factor = Math.Max(Factor, m_SHStatic[0].Max());
                }
                if (m_bShowSHDynamic)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        Color += (float)_Pixel.SHCoeffs[i] * m_SHDynamic[i];
                    }
                    Factor = Math.Max(Factor, m_SHDynamic[0].Max());
                }
                if (m_bShowSHEmissive)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        Color += (float)_Pixel.SHCoeffs[i] * m_SHEmissive[i];
                    }
                    Factor = Math.Max(Factor, m_SHEmissive[0].Max());
                }
                if (m_bShowSHOcclusion)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        Color += (float)_Pixel.SHCoeffs[i] * m_SHOcclusion[i] * float3.One;
                    }
                    Factor = Math.Max(Factor, m_SHOcclusion[0]);
                }

//				Color *= 50.0f;

                Color *= m_bNormalizeSH ? 1.0f / Factor : 1.0f;
            }

            if (Color.x < 0.0f || Color.y < 0.0f || Color.z < 0.0f)
            {
                Color.Set(1, 0, 1);
            }

            _R = (byte)Math.Min(255, 255 * Color.x);
            _G = (byte)Math.Min(255, 255 * Color.y);
            _B = (byte)Math.Min(255, 255 * Color.z);
        }
Beispiel #8
0
        private void    CubeMapSamplerNeighborProbeID(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            byte C = (byte)Math.Min(255, 255 * ((1 + _Pixel.NeighborProbeID) % 4) / 4);

            _R = _G = _B = C;
        }
Beispiel #9
0
        private void    CubeMapSamplerEmissiveMatID(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            byte C = (byte)Math.Min(255, 255 * ((1 + _Pixel.EmissiveMatID) % 4) / 4);

            _R = _G = _B = C;
        }
Beispiel #10
0
        private void    CubeMapSamplerFaceIndex(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            byte C = (byte)(_Pixel.FaceIndex & 0xFF);

            _R = _G = _B = C;
        }
Beispiel #11
0
 private void    CubeMapSamplerStaticLit(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
 {
     _R = (byte)Math.Min(255, 255 * _Pixel.StaticLitColor.x);
     _G = (byte)Math.Min(255, 255 * _Pixel.StaticLitColor.y);
     _B = (byte)Math.Min(255, 255 * _Pixel.StaticLitColor.z);
 }
Beispiel #12
0
        private void    CubeMapSamplerDistance(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
        {
            byte C = (byte)Math.Min(255, 255 * 0.1f * _Pixel.Distance);

            _R = _G = _B = C;
        }
Beispiel #13
0
 private void    CubeMapSamplerAlbedo(Probe.Pixel _Pixel, out byte _R, out byte _G, out byte _B)
 {
     _R = (byte)Math.Min(255, 255 * _Pixel.Albedo.x);
     _G = (byte)Math.Min(255, 255 * _Pixel.Albedo.y);
     _B = (byte)Math.Min(255, 255 * _Pixel.Albedo.z);
 }