Exemplo n.º 1
0
        void    BuildNoiseTextures()
        {
            PixelsBuffer Content   = new PixelsBuffer(NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * 4);
            PixelsBuffer Content4D = new PixelsBuffer(NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * 16);

            WMath.SimpleRNG.SetSeed(521288629, 362436069);

            float4 V = float4.Zero;

            using (BinaryWriter W = Content.OpenStreamWrite()) {
                using (BinaryWriter W2 = Content4D.OpenStreamWrite()) {
                    for (int Z = 0; Z < NOISE_SIZE; Z++)
                    {
                        for (int Y = 0; Y < NOISE_SIZE; Y++)
                        {
                            for (int X = 0; X < NOISE_SIZE; X++)
                            {
                                V.Set((float)WMath.SimpleRNG.GetUniform(), (float)WMath.SimpleRNG.GetUniform(), (float)WMath.SimpleRNG.GetUniform(), (float)WMath.SimpleRNG.GetUniform());
                                W.Write(V.x);
                                W2.Write(V.x);
                                W2.Write(V.y);
                                W2.Write(V.z);
                                W2.Write(V.w);
                            }
                        }
                    }
                }
            }

            m_Tex_Noise   = new Texture3D(m_Device, NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, 1, PIXEL_FORMAT.R8_UNORM, false, false, new PixelsBuffer[] { Content });
            m_Tex_Noise4D = new Texture3D(m_Device, NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, 1, PIXEL_FORMAT.RGBA8_UNORM, false, false, new PixelsBuffer[] { Content4D });
        }
Exemplo n.º 2
0
        void    BuildNoiseTextures()
        {
            PixelsBuffer Content   = new PixelsBuffer(NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * 4);
            PixelsBuffer Content4D = new PixelsBuffer(NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * 16);

            SimpleRNG.SetSeed(521288629, 362436069);

            float4 V = float4.Zero;

            using (BinaryWriter W = Content.OpenStreamWrite()) {
                using (BinaryWriter W2 = Content4D.OpenStreamWrite()) {
                    for (int Z = 0; Z < NOISE_SIZE; Z++)
                    {
                        for (int Y = 0; Y < NOISE_SIZE; Y++)
                        {
                            for (int X = 0; X < NOISE_SIZE; X++)
                            {
                                V.Set((float)SimpleRNG.GetUniform(), (float)SimpleRNG.GetUniform(), (float)SimpleRNG.GetUniform(), (float)SimpleRNG.GetUniform());
                                W.Write(V.x);
                                W2.Write(V.x);
                                W2.Write(V.y);
                                W2.Write(V.z);
                                W2.Write(V.w);
                            }
                        }
                    }
                }
            }

            m_tex_Noise   = new Texture3D(m_device, NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, 1, ImageUtility.PIXEL_FORMAT.R8, ImageUtility.COMPONENT_FORMAT.UNORM, false, false, new PixelsBuffer[] { Content });
            m_tex_Noise4D = new Texture3D(m_device, NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, 1, ImageUtility.PIXEL_FORMAT.RGBA8, ImageUtility.COMPONENT_FORMAT.UNORM, false, false, new PixelsBuffer[] { Content4D });

            // Load blue noise
            using (ImageUtility.ImageFile I = new ImageUtility.ImageFile(new FileInfo("BlueNoise64x64_16bits.png"))) {
                ImageUtility.ImagesMatrix M = new ImageUtility.ImagesMatrix(new ImageUtility.ImageFile[, ] {
                    { I }
                });
                m_tex_BlueNoise = new Texture2D(m_device, M, ImageUtility.COMPONENT_FORMAT.UNORM);
            }
        }
Exemplo n.º 3
0
        void    LoadProbePixels(FileInfo _FileName)
        {
            if (m_Tex_CubeMap != null)
            {
                m_Tex_CubeMap.Dispose();
                m_Tex_CubeMap = null;
            }
            if (m_SB_Samples != null)
            {
                m_SB_Samples.Dispose();
                m_SB_Samples = null;
            }
            if (m_SB_EmissiveSurfaces != null)
            {
                m_SB_EmissiveSurfaces.Dispose();
                m_SB_EmissiveSurfaces = null;
            }

            using (FileStream S = _FileName.OpenRead())
                using (BinaryReader R = new BinaryReader(S)) {
                    //////////////////////////////////////////////////////////////////
                    // Read pixels
                    Pixel[][,]      CubeMapFaces = new Pixel[6][, ];

                    int CubeMapSize = R.ReadInt32();
                    for (int CubeMapFaceIndex = 0; CubeMapFaceIndex < 6; CubeMapFaceIndex++)
                    {
                        Pixel[,]        Face           = new Pixel[CubeMapSize, CubeMapSize];
                        CubeMapFaces[CubeMapFaceIndex] = Face;

                        for (int Y = 0; Y < CubeMapSize; Y++)
                        {
                            for (int X = 0; X < CubeMapSize; X++)
                            {
                                Face[X, Y].ParentSampleIndex = R.ReadUInt32();
                                Face[X, Y].UsedForSampling   = R.ReadBoolean();
                                Face[X, Y].Position.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].Normal.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].Albedo.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].F0.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].StaticLitColor.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].SmoothedStaticLitColor.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                                Face[X, Y].FaceIndex             = R.ReadUInt32();
                                Face[X, Y].EmissiveMatID         = R.ReadUInt32();
                                Face[X, Y].NeighborProbeID       = R.ReadUInt32();
                                Face[X, Y].NeighborProbeDistance = R.ReadSingle();
                                Face[X, Y].VoronoiProbeID        = R.ReadUInt32();
                                Face[X, Y].Importance            = R.ReadDouble();
                                Face[X, Y].Distance         = R.ReadSingle();
                                Face[X, Y].SmoothedDistance = R.ReadSingle();
                                Face[X, Y].Infinity         = R.ReadByte() != 0;
                                Face[X, Y].SmoothedInfinity = R.ReadSingle();
                            }
                        }
                    }

                    List <PixelsBuffer> Content = new List <PixelsBuffer>();
                    float4 Value = new float4();

                    for (int CubeIndex = 0; CubeIndex < 8; CubeIndex++)
                    {
                        for (int CubeMapFaceIndex = 0; CubeMapFaceIndex < 6; CubeMapFaceIndex++)
                        {
                            PixelsBuffer Buff = new PixelsBuffer(CubeMapSize * CubeMapSize * 16);
                            Content.Add(Buff);

                            using (BinaryWriter W = Buff.OpenStreamWrite()) {
                                for (int Y = 0; Y < CubeMapSize; Y++)
                                {
                                    for (int X = 0; X < CubeMapSize; X++)
                                    {
                                        Pixel P = CubeMapFaces[CubeMapFaceIndex][X, Y];
                                        switch (CubeIndex)
                                        {
                                        case 0:
                                            Value.Set(P.Position, P.Distance);
                                            break;

                                        case 1:
                                            Value.Set(P.Normal, P.SmoothedDistance);
                                            break;

                                        case 2:
                                            Value.Set(P.Albedo, P.SmoothedInfinity);
                                            break;

                                        case 3:
                                            Value.Set(P.StaticLitColor, (float)P.ParentSampleIndex);
                                            break;

                                        case 4:
                                            Value.Set(P.SmoothedStaticLitColor, (float)P.Importance);
                                            break;

                                        case 5:
                                            Value.Set(P.UsedForSampling ? 1 : 0, P.Infinity ? 1 : 0, (float)P.FaceIndex, (float)P.VoronoiProbeID);
                                            break;

                                        case 6:
                                            Value.Set(P.F0, (float)P.NeighborProbeID);
                                            break;

                                        case 7:
                                            Value.Set(P.NeighborProbeDistance, 0, 0, 0);
                                            break;
                                        }
                                        W.Write(Value.x);
                                        W.Write(Value.y);
                                        W.Write(Value.z);
                                        W.Write(Value.w);
                                    }
                                }
                            }
                        }
                    }

                    m_Tex_CubeMap = new Texture2D(m_Device, CubeMapSize, CubeMapSize, -6 * 8, 1, PIXEL_FORMAT.RGBA32_FLOAT, false, false, Content.ToArray());

                    //////////////////////////////////////////////////////////////////
                    // Read samples
                    int SamplesCount = (int)R.ReadUInt32();
                    m_SB_Samples = new StructuredBuffer <SB_Sample>(m_Device, SamplesCount, true);

                    for (int SampleIndex = 0; SampleIndex < SamplesCount; SampleIndex++)
                    {
                        m_SB_Samples.m[SampleIndex].ID = (uint)SampleIndex;
                        m_SB_Samples.m[SampleIndex].Position.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                        m_SB_Samples.m[SampleIndex].Normal.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                        m_SB_Samples.m[SampleIndex].Albedo.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                        m_SB_Samples.m[SampleIndex].F0.Set(R.ReadSingle(), R.ReadSingle(), R.ReadSingle());
                        m_SB_Samples.m[SampleIndex].PixelsCount = R.ReadUInt32();
                        m_SB_Samples.m[SampleIndex].SHFactor    = R.ReadSingle();

                        m_SB_Samples.m[SampleIndex].SH0.Set((float)R.ReadDouble(), (float)R.ReadDouble(), (float)R.ReadDouble());
                        m_SB_Samples.m[SampleIndex].SH1.Set((float)R.ReadDouble(), (float)R.ReadDouble(), (float)R.ReadDouble());
                        m_SB_Samples.m[SampleIndex].SH2.Set((float)R.ReadDouble(), (float)R.ReadDouble(), (float)R.ReadDouble());
                    }
                    m_SB_Samples.Write();
                }
        }
Exemplo n.º 4
0
        void LoadProbePixels( FileInfo _FileName )
        {
            if ( m_Tex_CubeMap != null ) {
                m_Tex_CubeMap.Dispose();
                m_Tex_CubeMap = null;
            }
            if ( m_SB_Samples != null ) {
                m_SB_Samples.Dispose();
                m_SB_Samples = null;
            }
            if ( m_SB_EmissiveSurfaces != null ) {
                m_SB_EmissiveSurfaces.Dispose();
                m_SB_EmissiveSurfaces = null;
            }

            using ( FileStream S = _FileName.OpenRead() )
                using ( BinaryReader R = new BinaryReader( S ) ) {

                    //////////////////////////////////////////////////////////////////
                    // Read pixels
                    Pixel[][,]	CubeMapFaces = new Pixel[6][,];

                    int	CubeMapSize = R.ReadInt32();
                    for ( int CubeMapFaceIndex=0; CubeMapFaceIndex < 6; CubeMapFaceIndex++ ) {
                        Pixel[,]	Face = new Pixel[CubeMapSize,CubeMapSize];
                        CubeMapFaces[CubeMapFaceIndex] = Face;

                        for ( int Y=0; Y < CubeMapSize; Y++ )
                            for ( int X=0; X < CubeMapSize; X++ ) {
                                Face[X,Y].ParentSampleIndex = R.ReadUInt32();
                                Face[X,Y].UsedForSampling = R.ReadBoolean();
                                Face[X,Y].Position.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].Normal.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].Albedo.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].F0.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].StaticLitColor.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].SmoothedStaticLitColor.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                                Face[X,Y].FaceIndex = R.ReadUInt32();
                                Face[X,Y].EmissiveMatID = R.ReadUInt32();
                                Face[X,Y].NeighborProbeID = R.ReadUInt32();
                                Face[X,Y].NeighborProbeDistance = R.ReadSingle();
                                Face[X,Y].VoronoiProbeID = R.ReadUInt32();
                                Face[X,Y].Importance = R.ReadDouble();
                                Face[X,Y].Distance = R.ReadSingle();
                                Face[X,Y].SmoothedDistance = R.ReadSingle();
                                Face[X,Y].Infinity = R.ReadByte() != 0;
                                Face[X,Y].SmoothedInfinity = R.ReadSingle();
                            }

                    }

             					List<PixelsBuffer>	Content = new List<PixelsBuffer>();
                    float4				Value = new float4();

                    for ( int CubeIndex=0; CubeIndex < 8; CubeIndex++ ) {
                        for ( int CubeMapFaceIndex=0; CubeMapFaceIndex < 6; CubeMapFaceIndex++ ) {
                            PixelsBuffer	Buff = new PixelsBuffer( CubeMapSize*CubeMapSize * 16 );
                            Content.Add( Buff );

                            using ( BinaryWriter W = Buff.OpenStreamWrite() ) {
                                for ( int Y=0; Y < CubeMapSize; Y++ )
                                    for ( int X=0; X < CubeMapSize; X++ ) {
                                        Pixel	P = CubeMapFaces[CubeMapFaceIndex][X,Y];
                                        switch ( CubeIndex ) {
                                            case 0:
                                                Value.Set( P.Position, P.Distance );
                                                break;
                                            case 1:
                                                Value.Set( P.Normal, P.SmoothedDistance );
                                                break;
                                            case 2:
                                                Value.Set( P.Albedo, P.SmoothedInfinity );
                                                break;
                                            case 3:
                                                Value.Set( P.StaticLitColor, (float) P.ParentSampleIndex );
                                                break;
                                            case 4:
                                                Value.Set( P.SmoothedStaticLitColor, (float) P.Importance );
                                                break;
                                            case 5:
                                                Value.Set( P.UsedForSampling ? 1 : 0, P.Infinity ? 1 : 0, (float) P.FaceIndex, (float) P.VoronoiProbeID );
                                                break;
                                            case 6:
                                                Value.Set( P.F0, (float) P.NeighborProbeID );
                                                break;
                                            case 7:
                                                Value.Set( P.NeighborProbeDistance, 0, 0, 0 );
                                                break;
                                        }
                                        W.Write( Value.x );
                                        W.Write( Value.y );
                                        W.Write( Value.z );
                                        W.Write( Value.w );
                                    }
                            }
                        }
                    }

             					m_Tex_CubeMap = new Texture2D( m_Device, CubeMapSize, CubeMapSize, -6*8, 1, PIXEL_FORMAT.RGBA32_FLOAT, false, false, Content.ToArray() );

                    //////////////////////////////////////////////////////////////////
                    // Read samples
                    int	SamplesCount = (int) R.ReadUInt32();
                    m_SB_Samples = new StructuredBuffer<SB_Sample>( m_Device, SamplesCount, true );

                    for ( int SampleIndex=0; SampleIndex < SamplesCount; SampleIndex++ ) {
                        m_SB_Samples.m[SampleIndex].ID = (uint) SampleIndex;
                        m_SB_Samples.m[SampleIndex].Position.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                        m_SB_Samples.m[SampleIndex].Normal.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                        m_SB_Samples.m[SampleIndex].Albedo.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                        m_SB_Samples.m[SampleIndex].F0.Set( R.ReadSingle(), R.ReadSingle(), R.ReadSingle() );
                        m_SB_Samples.m[SampleIndex].PixelsCount = R.ReadUInt32();
                        m_SB_Samples.m[SampleIndex].SHFactor = R.ReadSingle();

                        m_SB_Samples.m[SampleIndex].SH0.Set( (float) R.ReadDouble(), (float) R.ReadDouble(), (float) R.ReadDouble() );
                        m_SB_Samples.m[SampleIndex].SH1.Set( (float) R.ReadDouble(), (float) R.ReadDouble(), (float) R.ReadDouble() );
                        m_SB_Samples.m[SampleIndex].SH2.Set( (float) R.ReadDouble(), (float) R.ReadDouble(), (float) R.ReadDouble() );
                    }
                    m_SB_Samples.Write();
                }
        }