Esempio n. 1
0
 private void Form_Load(object sender, EventArgs e)
 {
     {
         var camera = new Camera(
             new vec3(0, 0, 5), new vec3(0, 0, 0), new vec3(0, 1, 0),
             CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
         var rotator = new SatelliteManipulater();
         rotator.Bind(camera, this.glCanvas1);
         rotator.BindingMouseButtons = System.Windows.Forms.MouseButtons.Left | System.Windows.Forms.MouseButtons.Right;
         this.rotator           = rotator;
         this.scene             = new Scene(camera, this.glCanvas1);
         this.glCanvas1.Resize += this.scene.Resize;
     }
     {
         Teapot model = new Teapot();
         OrderDependentTransparencyRenderer renderer = OrderDependentTransparencyRenderer.Create(model, model.Lengths, Teapot.strPosition, Teapot.strColor);
         SceneObject obj = renderer.WrapToSceneObject();
         this.scene.RootObject.Children.Add(obj);
     }
     {
         var builder = new StringBuilder();
         builder.AppendLine("1: Scene's property grid.");
         builder.AppendLine("2: Canvas' property grid.");
         MessageBox.Show(builder.ToString());
     }
 }
Esempio n. 2
0
        public static OrderDependentTransparencyRenderer Create(IBufferable model, string position, string color)
        {
            var shaderCodes = new ShaderCode[2];

            shaderCodes[0] = new ShaderCode(File.ReadAllText(@"shaders\Transparent.vert"), ShaderType.VertexShader);
            shaderCodes[1] = new ShaderCode(File.ReadAllText(@"shaders\Transparent.frag"), ShaderType.FragmentShader);
            var map = new PropertyNameMap();

            map.Add("in_Position", position);
            map.Add("in_Color", color);
            var renderer = new OrderDependentTransparencyRenderer(model, shaderCodes, map, position, new BlendSwitch(BlendingSourceFactor.SourceAlpha, BlendingDestinationFactor.OneMinusSourceAlpha));

            renderer.Name = "Order-Dependent Transparent Renderer";

            return(renderer);
        }
        public static OrderDependentTransparencyRenderer Create(IBufferable model, vec3 lengths, string position, string color)
        {
            var shaderCodes = new ShaderCode[2];

            shaderCodes[0] = new ShaderCode(File.ReadAllText(@"shaders\ODT\Transparent.vert"), ShaderType.VertexShader);
            shaderCodes[1] = new ShaderCode(File.ReadAllText(@"shaders\ODT\Transparent.frag"), ShaderType.FragmentShader);
            var provider = new ShaderCodeArray(shaderCodes);
            var map      = new AttributeMap();

            map.Add("in_Position", position);
            map.Add("in_Color", color);
            var renderer = new OrderDependentTransparencyRenderer(model, provider, map, position, new BlendState(BlendingSourceFactor.SourceAlpha, BlendingDestinationFactor.OneMinusSourceAlpha));

            renderer.ModelSize = lengths;

            return(renderer);
        }
Esempio n. 4
0
 private void Form_Load(object sender, EventArgs e)
 {
     {
         var camera = new Camera(
             new vec3(0, 0, 5), new vec3(0, 0, 0), new vec3(0, 1, 0),
             CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
         var rotator = new SatelliteManipulater();
         rotator.Bind(camera, this.glCanvas1);
         rotator.BindingMouseButtons = System.Windows.Forms.MouseButtons.Left | System.Windows.Forms.MouseButtons.Right;
         this.rotator           = rotator;
         this.scene             = new Scene(camera, this.glCanvas1);
         this.glCanvas1.Resize += this.scene.Resize;
     }
     {
         IBufferable bufferable = new Teapot();
         OrderDependentTransparencyRenderer renderer = OrderDependentTransparencyRenderer.Create(bufferable, "position", "color");
         renderer.Initialize();
         SceneObject obj = renderer.WrapToSceneObject();
         this.scene.RootObject.Children.Add(obj);
     }
 }
Esempio n. 5
0
        public static RendererBase Create(Type rendererType)
        {
            RendererBase renderer = null;

            if (rendererType == typeof(AnalyzedPointSpriteRenderer))
            {
                int particleCount = 10000;
                renderer = AnalyzedPointSpriteRenderer.Create(particleCount);
            }
            else if (rendererType == typeof(BufferBlockRenderer))
            {
                renderer = BufferBlockRenderer.Create();
            }
            else if (rendererType == typeof(ConditionalRenderer))
            {
                renderer = ConditionalRenderer.Create();
            }
            else if (rendererType == typeof(EmitNormalLineRenderer))
            {
                var model = new Teapot();
                renderer = EmitNormalLineRenderer.Create(model, Teapot.strPosition, Teapot.strNormal, model.Lengths);
            }
            else if (rendererType == typeof(ImageProcessingRenderer))
            {
                renderer = new ImageProcessingRenderer();
            }
            else if (rendererType == typeof(KleinBottleRenderer))
            {
                renderer = KleinBottleRenderer.Create(new KleinBottleModel());
            }
            else if (rendererType == typeof(OrderDependentTransparencyRenderer))
            {
                var model = new Teapot();
                renderer = OrderDependentTransparencyRenderer.Create(model, model.Lengths, Teapot.strPosition, Teapot.strColor);
            }
            else if (rendererType == typeof(OrderIndependentTransparencyRenderer))
            {
                var model = new Teapot();
                renderer = new OrderIndependentTransparencyRenderer(model, model.Lengths, Teapot.strPosition, Teapot.strColor);
            }
            else if (rendererType == typeof(ParticleSimulatorRenderer))
            {
                renderer = new ParticleSimulatorRenderer();
            }
            else if (rendererType == typeof(PointCloudRenderer))
            {
                var list = new List <vec3>();

                using (var reader = new StreamReader(@"Resources\data\19PointCloud.txt"))
                {
                    while (!reader.EndOfStream)
                    {
                        string   line  = reader.ReadLine();
                        string[] parts = line.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                        float    x     = float.Parse(parts[0]);
                        float    y     = float.Parse(parts[1]);
                        float    z     = float.Parse(parts[2]);
                        list.Add(new vec3(x, y, z));
                    }
                }
                renderer = PointCloudRenderer.Create(new PointCloudModel(list));
            }
            else if (rendererType == typeof(PointSpriteRenderer))
            {
                const int particleCount = 10000;
                renderer = PointSpriteRenderer.Create(particleCount);
            }
            else if (rendererType == typeof(RaycastVolumeRenderer))
            {
                renderer = new RaycastVolumeRenderer();
            }
            else if (rendererType == typeof(RayTracingRenderer))
            {
                renderer = RayTracingRenderer.Create();
            }
            else if (rendererType == typeof(ShaderToyRenderer))
            {
                renderer = ShaderToyRenderer.Create();
            }
            else if (rendererType == typeof(SimpleComputeRenderer))
            {
                renderer = SimpleComputeRenderer.Create();
            }
            else if (rendererType == typeof(SimplexNoiseRenderer))
            {
                renderer = SimplexNoiseRenderer.Create();
            }
            else if (rendererType == typeof(UniformArrayRenderer))
            {
                renderer = UniformArrayRenderer.Create();
            }
            else if (rendererType == typeof(UniformBlockRenderer))
            {
                renderer = UniformBlockRenderer.Create();
            }
            else if (rendererType == typeof(UniformStructRenderer))
            {
                renderer = UniformStructRenderer.Create();
            }
            else if (rendererType == typeof(WaterRenderer))
            {
                renderer = WaterRenderer.Create(waterPlaneLength: 4);
            }
            else if (rendererType == typeof(ZeroAttributeRenderer))
            {
                renderer = ZeroAttributeRenderer.Create();
            }

            return(renderer);
        }