Пример #1
0
        public void             SampleCubeMap(float3 _View, CubeMapSampler _Sampler, out byte _R, out byte _G, out byte _B)
        {
            AbsView.Set(Math.Abs(_View.x), Math.Abs(_View.y), Math.Abs(_View.z));
            float MaxComponent = Math.Max(Math.Max(AbsView.x, AbsView.y), AbsView.z);

            fXYZ.Set(_View.x / MaxComponent, _View.y / MaxComponent, _View.z / MaxComponent);
            int FaceIndex = 0;

            if (Math.Abs(fXYZ.x) > 1.0 - 1e-6)
            {                   // +X or -X
                if (_View.x > 0.0)
                {
                    FaceIndex = 0;
                    fXY.Set(-fXYZ.z, fXYZ.y);
                }
                else
                {
                    FaceIndex = 1;
                    fXY.Set(fXYZ.z, fXYZ.y);
                }
            }
            else if (Math.Abs(fXYZ.y) > 1.0 - 1e-6)
            {                   // +Y or -Y
                if (_View.y > 0.0)
                {
                    FaceIndex = 2;
                    fXY.Set(fXYZ.x, -fXYZ.z);
                }
                else
                {
                    FaceIndex = 3;
                    fXY.Set(fXYZ.x, fXYZ.z);
                }
            }
            else             // if ( Math.Abs( fXYZ.z ) > 1.0-1e-6 )
            {                // +Z or -Z
                if (_View.z > 0.0)
                {
                    FaceIndex = 4;
                    fXY.Set(fXYZ.x, fXYZ.y);
                }
                else
                {
                    FaceIndex = 5;
                    fXY.Set(-fXYZ.x, fXYZ.y);
                }
            }

            fXY.y = -fXY.y;

            int X = (int)(Probe.CUBE_MAP_SIZE * 0.5 * (1.0 + fXY.x));
            int Y = (int)(Probe.CUBE_MAP_SIZE * 0.5 * (1.0 + fXY.y));

//          if ( X < 0 || X > Probe.CUBE_MAP_SIZE-1 )
//              throw new Exception();
//          if ( Y < 0 || Y > Probe.CUBE_MAP_SIZE-1 )
//              throw new Exception();

            X = Math.Min(Probe.CUBE_MAP_SIZE - 1, X);
            Y = Math.Min(Probe.CUBE_MAP_SIZE - 1, Y);

            Probe.Pixel[,]  CubeMapFace = m_Probe.m_CubeMap[FaceIndex];

            _Sampler(CubeMapFace[X, Y], out _R, out _G, out _B);
        }
Пример #2
0
		public void		SampleCubeMap( WMath.Vector _View, CubeMapSampler _Sampler, out byte _R, out byte _G, out byte _B )
		{
			AbsView.Set( Math.Abs( _View.x ), Math.Abs( _View.y ), Math.Abs( _View.z ) );
			float	MaxComponent = Math.Max( Math.Max( AbsView.x, AbsView.y ), AbsView.z );

			fXYZ.Set( _View.x / MaxComponent, _View.y / MaxComponent, _View.z / MaxComponent );
			int		FaceIndex = 0;
			if ( Math.Abs( fXYZ.x ) > 1.0-1e-6 )
			{	// +X or -X
				if ( _View.x > 0.0 )
				{
					FaceIndex = 0;
					fXY.Set( -fXYZ.z, fXYZ.y );
				}
				else
				{
					FaceIndex = 1;
					fXY.Set( fXYZ.z, fXYZ.y );
				}
			}
			else if ( Math.Abs( fXYZ.y ) > 1.0-1e-6 )
			{	// +Y or -Y
				if ( _View.y > 0.0 )
				{
					FaceIndex = 2;
					fXY.Set( fXYZ.x, -fXYZ.z );
				}
				else
				{
					FaceIndex = 3;
					fXY.Set( fXYZ.x, fXYZ.z );
				}
			}
			else // if ( Math.Abs( fXYZ.z ) > 1.0-1e-6 )
			{	// +Z or -Z
				if ( _View.z > 0.0 )
				{
					FaceIndex = 4;
					fXY.Set( fXYZ.x, fXYZ.y );
				}
				else
				{
					FaceIndex = 5;
					fXY.Set( -fXYZ.x, fXYZ.y );
				}
			}

			fXY.y = -fXY.y;

			int		X = (int) (Probe.CUBE_MAP_SIZE * 0.5 * (1.0 + fXY.x));
			int		Y = (int) (Probe.CUBE_MAP_SIZE * 0.5 * (1.0 + fXY.y));

// 			if ( X < 0 || X > Probe.CUBE_MAP_SIZE-1 )
// 				throw new Exception();
// 			if ( Y < 0 || Y > Probe.CUBE_MAP_SIZE-1 )
// 				throw new Exception();

			X = Math.Min( Probe.CUBE_MAP_SIZE-1, X );
			Y = Math.Min( Probe.CUBE_MAP_SIZE-1, Y );

			Probe.Pixel[,]	CubeMapFace = m_Probe.m_CubeMap[FaceIndex];

			_Sampler( CubeMapFace[X,Y], out _R, out _G, out _B );
		}
Пример #3
0
        public unsafe void              UpdateBitmap()
        {
            if (m_Bitmap == null)
            {
                return;
            }

            int W = m_Bitmap.Width;
            int H = m_Bitmap.Height;

            using (Graphics G = Graphics.FromImage(m_Bitmap))
            {
                G.FillRectangle(Brushes.White, 0, 0, W, H);
            }

            // Fill pixel per pixel
            if (m_Probe != null && m_Probe.m_CubeMap != null)
            {
                BitmapData LockedBitmap = m_Bitmap.LockBits(new Rectangle(0, 0, W, H), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

                CubeMapSampler S = CubeMapSamplerAlbedo;
                switch (m_Viz)
                {
                case VIZ_TYPE.ALBEDO:                           S = CubeMapSamplerAlbedo; break;

                case VIZ_TYPE.DISTANCE:                         S = CubeMapSamplerDistance; break;

                case VIZ_TYPE.NORMAL:                           S = CubeMapSamplerNormal; break;

                case VIZ_TYPE.STATIC_LIT:                       S = CubeMapSamplerStaticLit; break;

                case VIZ_TYPE.FACE_INDEX:                       S = CubeMapSamplerFaceIndex; break;

                case VIZ_TYPE.EMISSIVE_MAT_ID:          S = CubeMapSamplerEmissiveMatID; break;

                case VIZ_TYPE.NEIGHBOR_PROBE_ID:        S = CubeMapSamplerNeighborProbeID; break;

                case VIZ_TYPE.SET_INDEX:                        S = CubeMapSamplerSetIndex; break;

                case VIZ_TYPE.SET_ALBEDO:                       S = CubeMapSamplerSetAlbedo; break;

                case VIZ_TYPE.SET_DISTANCE:                     S = CubeMapSamplerSetDistance; break;

                case VIZ_TYPE.SET_NORMAL:                       S = CubeMapSamplerSetNormal; break;

                case VIZ_TYPE.SET_SAMPLES:                      S = CubeMapSamplerSetSamples; break;

                case VIZ_TYPE.SH:                                       S = CubeMapSamplerSH; break;
                }

                float3 View;
                byte   R, G, B, A = 0xFF;
                for (int Y = 0; Y < H; Y++)
                {
                    float y         = 1.0f - 2.0f * (0.5f + Y) / H;
                    byte *pScanline = (byte *)LockedBitmap.Scan0.ToPointer() + LockedBitmap.Stride * Y;
                    for (int X = 0; X < W; X++)
                    {
                        float x = 2.0f * (0.5f + X) / W - 1.0f;
                        View = x * m_Right + y * m_Up + m_At;
                        View = View.Normalized;

                        SampleCubeMap(View, S, out R, out G, out B);

                        *pScanline++ = B;
                        *pScanline++ = G;
                        *pScanline++ = R;
                        *pScanline++ = A;
                    }
                }


                m_Bitmap.UnlockBits(LockedBitmap);
            }

            Invalidate();
        }