Exemplo n.º 1
0
        public AtlasTests()
        {
            Stream       tmxStream = FileStreams.SmallPickupTmx();
            StreamReader tilesetTableStreamReader = new StreamReader(FileStreams.TilesetTableStream());

            TmxSerializer serializer = new TmxSerializer();
            Map           map        = serializer.Deserialize(tmxStream);
            ToyWorld      world      = new ToyWorld(map, tilesetTableStreamReader);

            m_atlas = world.Atlas;
        }
Exemplo n.º 2
0
        public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            if ((Settings.EnabledOverlays ^ RenderRequestOverlay.InventoryTool) == RenderRequestOverlay.None)
            {
                return;
            }

            Owner.FrontFbo.Bind();


            // some stuffs
        }
Exemplo n.º 3
0
        public LuaConsole(ToyWorld toyWorld, IAtlas atlas)
        {
            InitializeComponent();

            toyWorld.ToyWorldDisposed += CloseConsole;

            outputListBox.DataSource = m_inputOutputList;

            m_lex = new LuaExecutor(atlas, this);

            m_inputOutputList.Add(INVITATION_MESSAGE);
            ResetBox();
        }
Exemplo n.º 4
0
        public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, GameObjectSettings settings)
        {
            Settings = settings;

            GL.DepthFunc(DepthFunction.Lequal);
            //GL.DepthFunc(DepthFunction.Always); // Ignores stored depth values, but still writes them

            // Tileset textures
            {
                // Set up tileset textures
                IEnumerable <Tileset> tilesets      = world.TilesetTable.GetTilesetImages();
                TilesetImage[]        tilesetImages = tilesets.Select(
                    t =>
                    new TilesetImage(
                        t.Image.Source,
                        new Vector2I(t.Tilewidth, t.Tileheight),
                        new Vector2I(t.Spacing),
                        world.TilesetTable.TileBorder))
                                                      .ToArray();

                TilesetTexture = renderer.TextureManager.Get <TilesetTexture>(tilesetImages);
            }

            // Set up tile grid shader
            {
                Effect = renderer.EffectManager.Get <NoEffectOffset>();
                renderer.EffectManager.Use(Effect); // Need to use the effect to set uniforms

                // Set up static uniforms
                Vector2I fullTileSize = world.TilesetTable.TileSize + world.TilesetTable.TileMargins +
                                        world.TilesetTable.TileBorder * 2; // twice the border, on each side once
                Vector2 tileCount = (Vector2)TilesetTexture.Size / (Vector2)fullTileSize;
                Effect.TexSizeCountUniform(new Vector3I(TilesetTexture.Size.X, TilesetTexture.Size.Y, (int)tileCount.X));
                Effect.TileSizeMarginUniform(new Vector4I(world.TilesetTable.TileSize, world.TilesetTable.TileMargins));
                Effect.TileBorderUniform(world.TilesetTable.TileBorder);

                Effect.AmbientUniform(new Vector4(1, 1, 1, EffectPainter.AmbientTerm));
            }

            // Set up geometry
            if (settings.Use3D)
            {
                Cube = renderer.GeometryManager.Get <DuplicatedCube>();
            }
            else
            {
                Cube = renderer.GeometryManager.Get <Quad>();
            }

            IgnoredGameObjects.Clear();
        }
Exemplo n.º 5
0
        public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, PostprocessingSettings settings)
        {
            Settings = settings;

            if (Settings.EnabledPostprocessing.HasFlag(RenderRequestPostprocessing.Noise))
            {
                if (m_noiseEffect == null)
                {
                    m_noiseEffect = renderer.EffectManager.Get <NoiseEffect>();
                }
                renderer.EffectManager.Use(m_noiseEffect); // Need to use the effect to set uniforms
                m_noiseEffect.ViewportSizeUniform((Vector2I)Owner.Resolution);
                m_noiseEffect.SceneTextureUniform((int)RenderRequestBase.TextureBindPosition.PostEffectTextureBindPosition);
            }
        }
Exemplo n.º 6
0
        public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            if (Settings.CopyMode == RenderRequestImageCopyingMode.None)
            {
                return;
            }

            // Gather data to host mem
            Owner.FrontFbo.Bind();

            switch (Settings.CopyMode)
            {
            case RenderRequestImageCopyingMode.DefaultFbo:
                GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, 0);
                GL.BlitFramebuffer(
                    0, 0, Owner.FrontFbo.Size.X, Owner.FrontFbo.Size.Y,
                    0, 0, renderer.Width, renderer.Height,
                    ClearBufferMask.ColorBufferBit,
                    BlitFramebufferFilter.Nearest);
                break;

            case RenderRequestImageCopyingMode.OpenglPbo:
                Pbo.Bind();
                GL.ReadBuffer(ReadBufferMode.ColorAttachment0);     // Works for fbo bound to Framebuffer (not DrawFramebuffer)
                //Owner.FrontFbo[FramebufferAttachment.ColorAttachment0].Copy2D(PixelType.UnsignedByte); // This is half as fast as ReadPixels for color data
                GL.ReadPixels(0, 0, Owner.Resolution.Width, Owner.Resolution.Height, PixelFormat.Bgra, PixelType.UnsignedByte, default(IntPtr));

                if (Settings.CopyDepth)
                {
                    DepthPbo.Bind();
                    Owner.FrontFbo[FramebufferAttachment.DepthAttachment].Copy2D(PixelType.Float);     // This is twice as fast as ReadPixels for depth texture
                    //GL.ReadPixels(0, 0, Owner.Resolution.Width, Owner.Resolution.Height, PixelFormat.DepthComponent, PixelType.UnsignedInt, default(IntPtr));
                }
                break;

            case RenderRequestImageCopyingMode.Cpu:
                GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
                GL.ReadBuffer(ReadBufferMode.ColorAttachment0);     // Works for fbo bound to Framebuffer (not DrawFramebuffer)
                GL.ReadPixels(0, 0, Owner.Resolution.Width, Owner.Resolution.Height, PixelFormat.Bgra, PixelType.UnsignedByte, RenderedScene);

                if (Settings.CopyDepth)
                {
                    Owner.FrontFbo[FramebufferAttachment.DepthAttachment].Copy2D(PixelType.Float, RenderedSceneDepth);
                }
                break;
            }
        }
Exemplo n.º 7
0
            public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world)
            {
                if (Settings.EnabledOverlays == RenderRequestOverlay.None)
                {
                    return;
                }

                base.Draw(renderer, world);

                if (Settings.EnabledOverlays.HasFlag(RenderRequestOverlay.InventoryTool))
                {
                    DrawAvatarTool(
                        renderer, world.GetAvatar(Owner.AvatarID),
                        (Vector2)Settings.ToolSize, (Vector2)Settings.ToolPosition,
                        Settings.ToolBackground);
                }
            }
Exemplo n.º 8
0
        public void CheckDirtyParams(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            var gridView = GridView;


            // Get currently rendered layers
            m_toRender = GetTileLayersToRender().ToArray();

            if (Owner.DirtyParams.HasFlag(RenderRequestBase.DirtyParam.Size))
            {
                if (Settings.Use3D)
                {
                    Grid = renderer.GeometryManager.Get <DuplicatedCubeGrid>(gridView.Size);
                }
                else
                {
                    Grid = renderer.GeometryManager.Get <DuplicatedGrid>(gridView.Size);
                }

                // Reallocate stuff if needed -- texture holds tileTypes for all the layers
                int totalTileCount = gridView.Size.Size() * m_toRender.Length;
                Debug.Assert(totalTileCount < 1 << 14, "TileTypesTexture will overflow!");

                if (TileTypesTexure == null || totalTileCount > TileTypesTexure.Size.Size())
                {
                    // Init buffer
                    if (m_tileTypesBuffer != null)
                    {
                        m_tileTypesBuffer.Dispose();
                    }
                    m_tileTypesBuffer = new Pbo <ushort>(1);
                    m_tileTypesBuffer.Init(totalTileCount, hint: BufferUsageHint.StreamDraw);

                    // Init texture
                    if (TileTypesTexure != null)
                    {
                        TileTypesTexure.Dispose();
                    }
                    TileTypesTexure = renderer.TextureManager.Get <BasicTexture1D>(new Vector2I(totalTileCount, 1));
                    TileTypesTexure.DefaultInit();
                }
            }
        }
Exemplo n.º 9
0
        public void AvatarLoosingEnergy()
        {
            Stream       tmxStream = FileStreams.SmallPickupTmx();
            StreamReader tilesetTableStreamReader = new StreamReader(FileStreams.TilesetTableStream());

            TmxSerializer serializer = new TmxSerializer();
            Map           map        = serializer.Deserialize(tmxStream);

            m_worldPickupWorld = new ToyWorld(map, tilesetTableStreamReader);

            m_eater = m_worldPickupWorld.GetAvatar(m_worldPickupWorld.GetAvatarsIds()[0]);

            // Act
            for (int i = 0; i < 100; i++)
            {
                m_eater.Update(m_worldPickupWorld.Atlas, It.IsAny <TilesetTable>());
            }

            // Assert
            Assert.True(m_eater.Energy < 1);
        }
Exemplo n.º 10
0
        public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            if (Settings.EnabledGameObjects == RenderRequestGameObject.None)
            {
                return;
            }

            if (!Settings.Use3D)
            {
                GL.Enable(EnableCap.Blend);
                Owner.SetDefaultBlending();
            }
            else
            {
                GL.Disable(EnableCap.Blend);
            }

            GL.Enable(EnableCap.DepthTest);
            GL.DepthMask(true);

            // Bind stuff to GL
            renderer.TextureManager.Bind(TilesetTexture[0], Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.SummerTileset));
            renderer.TextureManager.Bind(TilesetTexture[1], Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.WinterTileset));
            renderer.TextureManager.Bind(TileTypesTexure, Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.TileTypes));
            renderer.EffectManager.Use(Effect);
            Effect.TextureUniform((int)RenderRequestBase.TextureBindPosition.SummerTileset);
            Effect.TextureWinterUniform((int)RenderRequestBase.TextureBindPosition.WinterTileset);
            Effect.TileTypesTextureUniform((int)RenderRequestBase.TextureBindPosition.TileTypes);
            Effect.DiffuseUniform(new Vector4(1, 1, 1, Owner.EffectPainter.GetGlobalDiffuseComponent(world)));
            Effect.TileVertexCountUniform(Settings.Use3D ? DuplicatedCubeGrid.FaceCount * 4 : 4);

            if (Settings.EnabledGameObjects.HasFlag(RenderRequestGameObject.TileLayers))
            {
                DrawTileLayers(renderer, world);
            }
            if (Settings.EnabledGameObjects.HasFlag(RenderRequestGameObject.ObjectLayers))
            {
                DrawObjectLayers(renderer, world);
            }
        }
Exemplo n.º 11
0
        public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, EffectSettings settings)
        {
            Settings = settings;

            if (Settings.EnabledEffects.HasFlag(RenderRequestEffect.Lights))
            {
                if (m_pointLightEffect == null)
                {
                    m_pointLightEffect = new PointLightEffect();
                }
            }

            if (Settings.EnabledEffects.HasFlag(RenderRequestEffect.Smoke))
            {
                if (m_smokeEffect == null)
                {
                    m_smokeEffect = renderer.EffectManager.Get <SmokeEffect>();
                }
                renderer.EffectManager.Use(m_smokeEffect); // Need to use the effect to set uniforms
                m_smokeEffect.SmokeColorUniform(new Vector4(Settings.SmokeColor.R, Settings.SmokeColor.G, Settings.SmokeColor.B, Settings.SmokeColor.A) / 255f);
            }
        }
Exemplo n.º 12
0
        protected virtual void DrawObjectLayers(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            var gridView = GridView;

            Effect.TileTypesIdxOffsetUniform(0);
            GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);

            // Draw objects
            foreach (var objectLayer in world.Atlas.ObjectLayers)
            {
                foreach (var gameObject in objectLayer.GetGameObjects(new RectangleF(gridView)))
                {
                    if (IgnoredGameObjects.Contains(gameObject) || gameObject.Invisible)
                    {
                        continue;
                    }

                    // Set up transformation to screen space for the gameObject
                    Matrix transform = Matrix.Identity;
                    // Model transform
                    IRotatable rotatableObject = gameObject as IRotatable;
                    if (rotatableObject != null)
                    {
                        transform *= Matrix.CreateRotationZ(rotatableObject.Rotation);
                    }
                    transform *= Matrix.CreateScale(new Vector3(gameObject.Size, objectLayer.Thickness) * 0.5f); // from (-1,1) to (-size,size)/2
                    // World transform
                    transform *= Matrix.CreateTranslation(new Vector3(gameObject.Position, objectLayer.SpanIntervalFrom + objectLayer.Thickness / 2));
                    // View and projection transforms
                    transform *= Owner.ViewProjectionMatrix;
                    Effect.ModelViewProjectionUniform(ref transform);

                    // Setup dynamic data
                    LocalTileTypesBuffer[0] = (ushort)gameObject.TilesetId;
                    TileTypesTexure.Update1D(1, dataType: PixelType.UnsignedShort, data: LocalTileTypesBuffer);
                    Cube.Draw();
                }
            }
        }
Exemplo n.º 13
0
        public void AvatarCanPickUp()
        {
            Stream       tmxStream = FileStreams.SmallPickupTmx();
            StreamReader tilesetTableStreamReader = new StreamReader(FileStreams.TilesetTableStream());

            TmxSerializer serializer = new TmxSerializer();
            Map           map        = serializer.Deserialize(tmxStream);

            m_worldPickupWorld = new ToyWorld(map, tilesetTableStreamReader);

            m_avatarPickuper        = m_worldPickupWorld.GetAvatar(m_worldPickupWorld.GetAvatarsIds()[0]);
            m_avatarPickuper.PickUp = true;

            Assert.Equal(null, m_avatarPickuper.Tool);

            // Act
            m_avatarPickuper.Update(m_worldPickupWorld.Atlas, It.IsAny <TilesetTable>());

            // Assert
            Assert.IsType <Apple>(m_avatarPickuper.Tool);
            Assert.False(m_avatarPickuper.PickUp);
        }
Exemplo n.º 14
0
        public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, OverlaySettings settings)
        {
            Settings = settings;

            // Set up overlay textures
            IEnumerable <Tileset> tilesets = world.TilesetTable.GetOverlayImages();

            TilesetImage[] tilesetImages = tilesets.Select(t =>
                                                           new TilesetImage(
                                                               t.Image.Source,
                                                               new Vector2I(t.Tilewidth, t.Tileheight),
                                                               new Vector2I(t.Spacing),
                                                               world.TilesetTable.TileBorder))
                                           .ToArray();

            m_overlayTexture = renderer.TextureManager.Get <TilesetTexture>(tilesetImages);

            // Set up overlay shader
            m_overlayEffect = renderer.EffectManager.Get <NoEffectOffset>();
            renderer.EffectManager.Use(m_overlayEffect); // Need to use the effect to set uniforms

            // Set up static uniforms
            Vector2I tileSize    = tilesetImages[0].TileSize;
            Vector2I tileMargins = tilesetImages[0].TileMargin;
            Vector2I tileBorder  = tilesetImages[0].TileBorder;

            Vector2I fullTileSize = tileSize + tileMargins + tileBorder * 2; // twice the border, on each side once
            Vector2  tileCount    = (Vector2)m_overlayTexture.Size / (Vector2)fullTileSize;

            m_overlayEffect.TexSizeCountUniform(new Vector3I(m_overlayTexture.Size.X, m_overlayTexture.Size.Y, (int)tileCount.X));
            m_overlayEffect.TileSizeMarginUniform(new Vector4I(tileSize, tileMargins));
            m_overlayEffect.TileBorderUniform(tileBorder);

            m_overlayEffect.AmbientUniform(new Vector4(1, 1, 1, 1));

            QuadOffset = renderer.GeometryManager.Get <Quad>();
        }
Exemplo n.º 15
0
        public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world)
        {
            if (Settings.EnabledEffects == RenderRequestEffect.None)
            {
                return;
            }

            GL.Enable(EnableCap.Blend);
            GL.Enable(EnableCap.DepthTest);
            GL.DepthMask(false);

            Owner.FrontFbo.Bind();

            const float effectHeight = 1.5f;

            if (Settings.EnabledEffects.HasFlag(RenderRequestEffect.Lights))
            {
                //GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.SrcAlpha); // Fades non-lit stuff to black
                GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.DstAlpha);

                renderer.EffectManager.Use(m_pointLightEffect);

                foreach (var character in world.Atlas.Characters)
                {
                    m_pointLightEffect.ColorUniform(new Vector4(0.85f));
                    float lightDecay = character.ForwardSpeed;
                    m_pointLightEffect.IntensityDecayUniform(new Vector2(1, lightDecay));
                    m_pointLightEffect.LightPosUniform(new Vector3(character.Position, effectHeight));

                    // Set up transformation to world and screen space for noise effect
                    Matrix mw = Matrix.Identity;
                    // Model transform -- scale from (-1,1) to viewSize/2, center on origin
                    const float minIntensity   = 0.01f;
                    const float intensityScale = (1 / minIntensity - 1) / 30;
                    mw *= Matrix.CreateScale(intensityScale / lightDecay / 2);
                    // World transform -- move center to view center
                    mw *= Matrix.CreateTranslation(new Vector3(character.Position, effectHeight));
                    m_pointLightEffect.ModelWorldUniform(ref mw);
                    Matrix mvp = mw * Owner.ViewProjectionMatrix;
                    m_pointLightEffect.ModelViewProjectionUniform(ref mvp);

                    Owner.Quad.Draw();
                }

                Owner.SetDefaultBlending();
            }

            if (Settings.EnabledEffects.HasFlag(RenderRequestEffect.Smoke))
            {
                renderer.EffectManager.Use(m_smokeEffect);

                // Set up transformation to world and screen space for noise effect
                Matrix mw = Matrix.Identity;
                // Model transform -- scale from (-1,1) to viewSize/2, center on origin
                mw *= Matrix.CreateScale(Owner.ViewV.Size / 2);
                // World transform -- move center to view center
                mw *= Matrix.CreateTranslation(new Vector3(Owner.ViewV.Center, effectHeight + 0.05f));
                // View and projection transforms
                Matrix mvp = mw * Owner.ViewProjectionMatrix;

                m_smokeEffect.ModelWorldUniform(ref mw);
                m_smokeEffect.ModelViewProjectionUniform(ref mvp);

                m_smokeEffect.AmbientDiffuseTermsUniform(new Vector2(AmbientTerm, GetGlobalDiffuseComponent(world)));

                // Advance noise time by a visually pleasing step; wrap around if we run for waaaaay too long.
                double step = 0.005d * Settings.SmokeTransformationSpeedCoefficient;
                double seed = renderer.SimTime * step % 3e6d;
                m_smokeEffect.TimeStepUniform(new Vector2((float)seed, (float)step));
                m_smokeEffect.MeanScaleUniform(new Vector2(Settings.SmokeIntensityCoefficient, Settings.SmokeScaleCoefficient));

                Owner.Quad.Draw();
            }

            // more stufffs
        }
Exemplo n.º 16
0
 public abstract void Draw(RendererBase <ToyWorld> renderer, ToyWorld world);
Exemplo n.º 17
0
 public abstract void Init(RendererBase <ToyWorld> renderer, ToyWorld world, TSettings settings);
Exemplo n.º 18
0
 public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, OverlaySettings settings)
 {
     base.Init(renderer, world, settings);
 }