Exemple #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="control"></param>
        public override void Load(Control control)
        {
            base.Load(control);

            camera = new PerspectiveCamera(60, control.Width / (float)control.Height, 1, 10000);
            this.camera.Position.Z = 100;

            this.cameraRtt            = new OrthographicCamera(control.Width / -2, control.Width / 2, control.Height / 2, control.Height / -2, -10000, 10000);
            this.cameraRtt.Position.Z = 100;

            scene         = new Scene();
            this.sceneRtt = new Scene();
            sceneScreen   = new Scene();

            var light = new DirectionalLight(Color.White);

            light.Position.set(0, 0, 1).Normalize();
            this.sceneRtt.Add(light);

            light = new DirectionalLight((Color)colorConvertor.ConvertFromString("#ffaaaa"), 1.5f);
            light.Position.set(0, 0, -1).Normalize();
            this.sceneRtt.Add(light);

            rtTexture = new WebGLRenderTarget(control.Width, control.Height)
            {
                MinFilter = ThreeCs.Three.LinearFilter, MagFilter = ThreeCs.Three.NearestFilter, Format = ThreeCs.Three.RGBFormat
            };

            material = new ShaderMaterial()
            {
                Uniforms = new Uniforms {
                    { "time", new Uniform()
                      {
                          { "type", "f" }, { "value", 0.0f }
                      } }
                },
                VertexShader   = VertexShader,
                FragmentShader = FragmentShaderPass1,
            };

            materialScreen = new ShaderMaterial()
            {
                Uniforms = new Uniforms {
                    { "tDiffuse", new Uniform()
                      {
                          { "type", "t" }, { "value", rtTexture }
                      } }
                },
                VertexShader   = VertexShader,
                FragmentShader = FragmentShaderScreen,
            };

            var plane = new PlaneBufferGeometry(control.Width, control.Height);

            quad            = new Mesh(plane, material);
            quad.Position.Z = -100;
            this.sceneRtt.Add(quad);

            var geometry = new TorusGeometry(100, 25, 15, 30);

            var mat1 = new MeshPhongMaterial()
            {
                Color = (Color)colorConvertor.ConvertFromString("#555555"), Specular = (Color)colorConvertor.ConvertFromString("#ffaa00"), Shininess = 5
            };
            var mat2 = new MeshPhongMaterial()
            {
                Color = (Color)colorConvertor.ConvertFromString("#550000"), Specular = (Color)colorConvertor.ConvertFromString("#ff2200"), Shininess = 5
            };

            zmesh1 = new Mesh(geometry, mat1);
            zmesh1.Position.set(0, 0, 100);
            zmesh1.Scale.set(1.5f, 1.5f, 1.5f);
            this.sceneRtt.Add(zmesh1);

            zmesh2 = new Mesh(geometry, mat2);
            zmesh2.Position.set(0, 150, 100);
            zmesh2.Scale.set(0.75f, 0.75f, 0.75f);
            this.sceneRtt.Add(zmesh2);

            quad            = new Mesh(plane, materialScreen);
            quad.Position.Z = -100;
            sceneScreen.Add(quad);

            //
            var geometry3 = new SphereGeometry(10, 64, 32);
            var material2 = new MeshBasicMaterial()
            {
                Color = Color.White                                                  /*, Map = rtTexture*/
            };

            int n = 5;

            for (var j = 0; j < n; j++)
            {
                for (var i = 0; i < n; i++)
                {
                    var mesh = new Mesh(geometry3, material2);

                    mesh.Position.X = (i - (n - 1) / 2) * 20;
                    mesh.Position.Y = (j - (n - 1) / 2) * 20;
                    mesh.Position.Z = 0;

                    mesh.Rotation.Y = (float)-Math.PI / 2.0f;

                    scene.Add(mesh);
                }
            }

            renderer.AutoClear = false;
        }
Exemple #2
0
 // Use this for initialization
 void Start()
 {
     geo             = new TorusGeometry();
     meshFilter.mesh = geo.CreateAndGetMesh();
 }
Exemple #3
0
        private static void Init()
        {
            camera = new PerspectiveCamera(renderer, 30, 1, 10000)
            {
                Position = new Vector3(0, 0, 100)
            };

            cameraRTT = new OrthographicCamera(renderer, -10000, 10000)
            {
                Position = new Vector3(0, 0, 100)
            };

            scene       = new Scene();
            sceneRTT    = new Scene();
            sceneScreen = new Scene();

            var light = new DirectionalLight(Color.White)
            {
                Position = Vector3.UnitZ.Normalized()
            };

            sceneRTT.Add(light);

            light = new DirectionalLight(new Color(0xffaaaa))
            {
                Position  = Vector3.UnitNegativeZ.Normalized(),
                Intensity = 1.5f
            };
            sceneRTT.Add(light);

            rtTexture = new RenderTarget(renderer.Width, renderer.Height)
            {
                MinFilter = TextureMinFilter.Linear,
                MagFilter = TextureMagFilter.Nearest,
                Format    = Three.Net.Renderers.PixelFormat.RGB
            };

            var vertexShaderSource = @"
varying vec2 vUv;
void main() 
{
	vUv = uv;
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}";

            var fragment_shader_screenSource = @"
varying vec2 vUv;
uniform sampler2D tDiffuse;
void main() 
{
	gl_FragColor = texture2D( tDiffuse, vUv );
}";
            var fragment_shader_pass_1Source = @"
varying vec2 vUv;
uniform float time;
void main() 
{
	float r = vUv.x;
	if( vUv.y < 0.5 ) r = 0.0;
	float g = vUv.y;
	if( vUv.x < 0.5 ) g = 0.0;

	gl_FragColor = vec4( r, g, time, 1.0 );
}";

            material = new CustomShaderMaterial(renderer, vertexShaderSource, fragment_shader_pass_1Source, m => { });

            var materialScreen = new CustomShaderMaterial(renderer, vertexShaderSource, fragment_shader_screenSource, m => {})
            {
                ShouldDepthWrite = false
            };

            var plane = new PlaneGeometry(renderer.Width, renderer.Height);
            var quad  = new Mesh(plane, material)
            {
                Position = new Vector3(0, 0, -100)
            };

            sceneRTT.Add(quad);

            var geometry = new TorusGeometry(100, 25, 15, 30);

            var mat1 = new MeshPhongMaterial(renderer)
            {
                Diffuse   = new Color(0x555555),
                Specular  = new Color(0xffaa00),
                Shininess = 5
            };
            var mat2 = new MeshPhongMaterial(renderer)
            {
                Diffuse   = new Color(0x550000),
                Specular  = new Color(0xff2200),
                Shininess = 5
            };

            zmesh1 = new Mesh(geometry, mat1)
            {
                Position = new Vector3(0, 0, 100),
                Scale    = new Vector3(1.5f, 1.5f, 1.5f)
            };
            sceneRTT.Add(zmesh1);

            zmesh2 = new Mesh(geometry, mat2)
            {
                Position = new Vector3(0, 150, 100),
                Scale    = new Vector3(0.75f, 0.75f, 0.75f)
            };
            sceneRTT.Add(zmesh2);

            quad = new Mesh(plane, materialScreen)
            {
                Position = new Vector3(0, 0, -100)
            };
            sceneScreen.Add(quad);

            var n = 5;
            var sphereGeometry = new SphereGeometry(10, 64, 32);
            var material2      = new MeshBasicMaterial(renderer)
            {
                Diffuse    = Color.White,
                DiffuseMap = rtTexture
            };

            for (var j = 0; j < n; j++)
            {
                for (var i = 0; i < n; i++)
                {
                    var mesh = new Mesh(sphereGeometry, material2)
                    {
                        Position = new Vector3(
                            (i - (n - 1) / 2) * 20,
                            (j - (n - 1) / 2) * 20,
                            0),
                        Rotation = new Euler(0, -Mathf.Pi / 2, 0)
                    };
                    scene.Add(mesh);
                }
            }

            renderer.ShouldAutoClear = false;
        }