public void MakeTreeScene()
        {
            Configuration.idBuffer = false;
#if DEBUG
            float size = 40.0f;
#else
            float size = 40.0f;
#endif
            Reset();

            AddFloor(size, 5, -0.5f);

            var tree1 = new TreeTemplate(22, 0, 4, 3.0f, 0.6f, 0.6f);
            var tree2 = new TreeTemplate(26, 0, 6, 7.0f, 1.0f, 0.6f);

            Random         r         = new Random();
            List <Vector2> positions = UniformPoissonDiskSampler.SampleCircle(Vector2.Zero, size / 2.0f, 3.0f);
            foreach (var pos in positions)
            {
                Vector3 p3d = new Vector3(pos.X, 0.0f, pos.Y);
                //Vector3 p3d = new Vector3(0.0, 0.0f, 0.0);
                double type = r.NextDouble();
                if (type > 0.5)
                {
                    MakeTree(p3d, tree1);
                }
                else
                {
                    MakeTree(p3d, tree2);
                }
            }

            AddCameras();
            AddCameraUserControls();
        }
Example #2
0
        //  http://developer.dev.nvidia.com/node/35?display=default
        //  http://read.pudn.com/downloads105/sourcecode/windows/opengl/433841/DEMOS/OpenGL/src/simple_soft_shadows/simple_soft_shadows.cpp__.htm
#if false // \bug OpenGL spec file or OpenTK bug
        private void CreateJitterTexture()
        {
            List <Vector2> samples = null;

            Random random        = new Random();
            int    jitterSize    = 32;
            int    jitterSamples = 64;
            int    width         = jitterSize;
            int    height        = jitterSize;
            //int     depth           = jitterSamples * jitterSamples / 2;
            int depth      = jitterSamples / 2;
            int texelPitch = 4;
            int rowPitch   = width * texelPitch;
            int slicePitch =  rowPitch * height;

            byte[] data = new byte[width * height * depth * texelPitch];

            Texture texture = new Texture(
                width,
                height,
                depth, PixelFormat.Rgba,
                PixelInternalFormat.SignedRgba8
                );

            double[] v             = new double[4];
            double[] d             = new double[4];
            float    startDistance = 0.5f;

            for (int i = 0; i < jitterSize; ++i)
            {
                for (int j = 0; j < jitterSize; ++j)
                {
                    double rot_offset = random.NextDouble() * 2 * 3.1415926;

                    float distance = startDistance;
                    for (int count = 0; count < jitterSamples; distance = distance * 0.95f)
                    {
                        samples = UniformPoissonDiskSampler.SampleCircle(Vector2.Zero, 1.0f, distance);
                        count   = samples.Count;
                    }
                    startDistance = distance / 0.95f;

                    for (int k = 0; k < jitterSamples / 2; ++k)
                    {
                        data[k * slicePitch + j * rowPitch + i * 4 + 0] = (byte)(samples[k * 2 + 0].X * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 1] = (byte)(samples[k * 2 + 0].Y * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 2] = (byte)(samples[k * 2 + 1].X * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 3] = (byte)(samples[k * 2 + 1].Y * 255);
                    }

#if false
                    for (int k = 0; k < jitterSamples * jitterSamples / 2; ++k)
                    {
                        int x, y;

                        x = k % (jitterSamples / 2);
                        y = (jitterSamples - 1) - k / (jitterSamples / 2);

                        v[0] = (double)(x * 2 + 0.5) / jitterSamples;
                        v[1] = (double)(y + 0.5) / jitterSamples;
                        v[2] = (double)(x * 2 + 1 + 0.5) / jitterSamples;
                        v[3] = v[1];

                        // jitter
                        v[0] += random.NextDouble() * 2 / jitterSamples;
                        v[1] += random.NextDouble() * 2 / jitterSamples;
                        v[2] += random.NextDouble() * 2 / jitterSamples;
                        v[3] += random.NextDouble() * 2 / jitterSamples;

                        // warp to disk
                        d[0] = Math.Sqrt(v[1]) * Math.Cos(2 * 3.1415926 * v[0] + rot_offset);
                        d[1] = Math.Sqrt(v[1]) * Math.Sin(2 * 3.1415926 * v[0] + rot_offset);
                        d[2] = Math.Sqrt(v[3]) * Math.Cos(2 * 3.1415926 * v[2] + rot_offset);
                        d[3] = Math.Sqrt(v[3]) * Math.Sin(2 * 3.1415926 * v[2] + rot_offset);

                        d[0] = (d[0] + 1.0) / 2.0;
                        d[1] = (d[1] + 1.0) / 2.0;
                        d[2] = (d[2] + 1.0) / 2.0;
                        d[3] = (d[3] + 1.0) / 2.0;
                        data[k * slicePitch + j * rowPitch + i * 4 + 0] = (byte)(d[0] * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 1] = (byte)(d[1] * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 2] = (byte)(d[2] * 255);
                        data[k * slicePitch + j * rowPitch + i * 4 + 3] = (byte)(d[3] * 255);
                    }
#endif
                }
            }

            texture.Upload(data, 0);
            texture.Wrap = TextureWrapMode.Repeat;

            renderer.GlobalParameters["jittermap"] = texture;
        }