ObjectType = Root
{
    Component* Components
    [
    ]
    
    Entity* Children
    [
        Element = OceanSurfaceEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 210;
                        
                        float Y = 100;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 33.2721;
                        
                        float Y = -88.7189;
                        
                        float Z = 2;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 470.797;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 8;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 0.5;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = 0;
                    
                    std::string Texture
                    {
                        char* String = "Surface/surface_displacement.png";
                    }
                    
                    int ShaderType = 8;
                }
                
                Element = OceanSurfaceLogic
                {
                    float wibbleSpeed = 0.1;
                    
                    float tweenTime = 10;
                    
                    float yoffset = -10;
                    
                    float zoffset = 5;
                    
                    float alphaFactor = 3;
                    
                    float gravFactor = 0.1;
                    
                    bool tweening = true;
                }
                
                Element = Light
                {
                    Vec2 Scale
                    {
                        float X = 400;
                        
                        float Y = 400;
                    }
                    
                    int LayerID = 0;
                    
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    std::string Texture
                    {
                        char* String = "light.png";
                    }
                    
                    int ShaderType = 5;
                }
                
                Element = ActionList
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 50;
                        
                        float Y = 50;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 26.892;
                        
                        float Y = 103.913;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -10;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_2.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 350;
                        
                        float Y = 350;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = -184.296;
                        
                        float Y = 94.5116;
                        
                        float Z = 450;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -9;
                    
                    std::string Texture
                    {
                        char* String = "alienPlanet_large.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 240;
                        
                        float Y = 240;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 13.789;
                        
                        float Y = 144.039;
                        
                        float Z = 375;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -8;
                    
                    std::string Texture
                    {
                        char* String = "alienPlanet_small.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 300;
                        
                        float Y = 300;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 220.627;
                        
                        float Y = -440.06;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.482031;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -7;
                    
                    std::string Texture
                    {
                        char* String = "water_gradient_overlay.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 222;
                        
                        float Y = 84.3;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 244.802;
                        
                        float Y = 79.5665;
                        
                        float Z = -117.7;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -6;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_1.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 300;
                        
                        float Y = 283;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 458.175;
                        
                        float Y = -1.90469;
                        
                        float Z = 600;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -10;
                    
                    std::string Texture
                    {
                        char* String = "alienSky.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 244;
                        
                        float Y = 500;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 60.2082;
                        
                        float Y = -507.992;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -6;
                    
                    std::string Texture
                    {
                        char* String = "ocean_bg.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = GameControllerEntity
        {
            Component* Components
            [
                Element = StateMachine
                
                Element = GameControllerLogic
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 29;
                        
                        float Y = 29;
                    }
                    
                    float Rotation = 1;
                    
                    Vec3 Position
                    {
                        float X = -73.4157;
                        
                        float Y = -439.784;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 6922.13;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 0.699219;
                            
                            float Z = 0.136719;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "bulbPlant_base.png";
                    }
                    
                    int ShaderType = 7;
                }
                
                Element = Light
                {
                    Vec2 Scale
                    {
                        float X = 100;
                        
                        float Y = 100;
                    }
                    
                    int LayerID = 0;
                    
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 0.383203;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    std::string Texture
                    {
                        char* String = "light.png";
                    }
                    
                    int ShaderType = 5;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 50.2001;
                        
                        float Y = 50.2001;
                    }
                    
                    float Rotation = 2.9;
                    
                    Vec3 Position
                    {
                        float X = 215.833;
                        
                        float Y = -264.492;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 6922.13;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 36.6001;
                        
                        float Y = 36.6001;
                    }
                    
                    float Rotation = 0.4;
                    
                    Vec3 Position
                    {
                        float X = -146.546;
                        
                        float Y = -174.792;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 6922.13;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 31.8;
                        
                        float Y = 31.8;
                    }
                    
                    float Rotation = 0.1;
                    
                    Vec3 Position
                    {
                        float X = -157.921;
                        
                        float Y = -159.402;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 6922.13;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 131.8;
                        
                        float Y = 147.9;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 371.115;
                        
                        float Y = 119.762;
                        
                        float Z = 250;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -7;
                    
                    std::string Texture
                    {
                        char* String = "alienMountains.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 222;
                        
                        float Y = 84.3;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 228.717;
                        
                        float Y = 84.6557;
                        
                        float Z = 190;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -6;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_1.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 600;
                        
                        float Y = 600;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = -27.7542;
                        
                        float Y = 33.1945;
                        
                        float Z = 600;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -10;
                    
                    std::string Texture
                    {
                        char* String = "alienSky.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 131.8;
                        
                        float Y = 147.9;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = -122.801;
                        
                        float Y = 124.081;
                        
                        float Z = 250;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -7;
                    
                    std::string Texture
                    {
                        char* String = "alienMountains.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 131.8;
                        
                        float Y = 147.9;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 135.51;
                        
                        float Y = 115.349;
                        
                        float Z = 250;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -7;
                    
                    std::string Texture
                    {
                        char* String = "alienMountains.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 222;
                        
                        float Y = 84.3;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = -138.945;
                        
                        float Y = 94.0425;
                        
                        float Z = 190;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -6;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_1.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 222;
                        
                        float Y = 84.3;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 30.4321;
                        
                        float Y = 63.3657;
                        
                        float Z = 190;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -6;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_1.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 18.6;
                        
                        float Y = 18.6;
                    }
                    
                    float Rotation = 0.8;
                    
                    Vec3 Position
                    {
                        float X = -167.928;
                        
                        float Y = -178.419;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2662.41;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 0.699219;
                            
                            float Z = 0.136719;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "bulbPlant_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = Entity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 15;
                        
                        float Y = 15;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 25.0628;
                        
                        float Y = -7.15569;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = 0;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_2.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 179.798;
                        
                        float Y = 179.798;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 266.212;
                        
                        float Y = 126.525;
                        
                        float Z = 181.6;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 5.10824;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -4;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_2.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 179.798;
                        
                        float Y = 179.798;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = -110.049;
                        
                        float Y = 131.245;
                        
                        float Z = 181.6;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 5.10824;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -4;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_2.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 179.798;
                        
                        float Y = 179.798;
                    }
                    
                    float Rotation = 0;
                    
                    Vec3 Position
                    {
                        float X = 93.5331;
                        
                        float Y = 143.043;
                        
                        float Z = 181.6;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 5.10824;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -4;
                    
                    std::string Texture
                    {
                        char* String = "alienFog_2.png";
                    }
                    
                    int ShaderType = 1;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 61.8001;
                        
                        float Y = 61.8001;
                    }
                    
                    float Rotation = 0.9;
                    
                    Vec3 Position
                    {
                        float X = -118.662;
                        
                        float Y = -192.796;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2342;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 62.6001;
                        
                        float Y = 62.6001;
                    }
                    
                    float Rotation = 6.8;
                    
                    Vec3 Position
                    {
                        float X = -104.811;
                        
                        float Y = -350.198;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2254.58;
                        }
                        
                        float glowStrength = 1.43594;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 0.86797;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 45.6;
                        
                        float Y = 45.6;
                    }
                    
                    float Rotation = 1.1;
                    
                    Vec3 Position
                    {
                        float X = 126.22;
                        
                        float Y = -596.451;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2130.71;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 61.8001;
                        
                        float Y = 61.8001;
                    }
                    
                    float Rotation = 7;
                    
                    Vec3 Position
                    {
                        float X = -90.2367;
                        
                        float Y = -370.11;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2118.22;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 73.6;
                        
                        float Y = 73.6;
                    }
                    
                    float Rotation = 6.9;
                    
                    Vec3 Position
                    {
                        float X = -108.386;
                        
                        float Y = -312.081;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2049.04;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 29;
                        
                        float Y = 29;
                    }
                    
                    float Rotation = 1.3;
                    
                    Vec3 Position
                    {
                        float X = -139.14;
                        
                        float Y = -209.317;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 2001.47;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 0.699219;
                            
                            float Z = 0.136719;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "bulbPlant_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 62.6001;
                        
                        float Y = 62.6001;
                    }
                    
                    float Rotation = 7.5;
                    
                    Vec3 Position
                    {
                        float X = -16.0319;
                        
                        float Y = -516.035;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 1939.96;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 62.6001;
                        
                        float Y = 62.6001;
                    }
                    
                    float Rotation = 7.5;
                    
                    Vec3 Position
                    {
                        float X = -39.9565;
                        
                        float Y = -495.683;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 1879.04;
                        }
                        
                        float glowStrength = 1.43594;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 0.86797;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 62.4002;
                        
                        float Y = 62.4002;
                    }
                    
                    float Rotation = 7.5;
                    
                    Vec3 Position
                    {
                        float X = 145.292;
                        
                        float Y = -581.474;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.263281;
                            
                            float Y = 1;
                            
                            float Z = 1;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "BulbRock_1.png";
                    }
                    
                    int ShaderType = 2;
                }
                
                Element = Light
                {
                    Vec2 Scale
                    {
                        float X = 100;
                        
                        float Y = 100;
                    }
                    
                    int LayerID = 0;
                    
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 1.16797;
                        
                        Vec3 glowColor
                        {
                            float X = -0.361328;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    std::string Texture
                    {
                        char* String = "light.png";
                    }
                    
                    int ShaderType = 5;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 29;
                        
                        float Y = 29;
                    }
                    
                    float Rotation = 0.8;
                    
                    Vec3 Position
                    {
                        float X = -1.09184;
                        
                        float Y = -556.117;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 849.48;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 1;
                            
                            float Y = 0.699219;
                            
                            float Z = 0.136719;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "bulbPlant_base.png";
                    }
                    
                    int ShaderType = 7;
                }
                
                Element = Light
                {
                    Vec2 Scale
                    {
                        float X = 100;
                        
                        float Y = 100;
                    }
                    
                    int LayerID = 0;
                    
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        float glowStrength = 0.383203;
                        
                        Vec3 glowColor
                        {
                            float X = 0;
                            
                            float Y = 0;
                            
                            float Z = 0;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    std::string Texture
                    {
                        char* String = "light.png";
                    }
                    
                    int ShaderType = 5;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 61.8001;
                        
                        float Y = 61.8001;
                    }
                    
                    float Rotation = 2.6;
                    
                    Vec3 Position
                    {
                        float X = 228.483;
                        
                        float Y = -222.699;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 712.747;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 61.8001;
                        
                        float Y = 61.8001;
                    }
                    
                    float Rotation = 2.6;
                    
                    Vec3 Position
                    {
                        float X = 191.909;
                        
                        float Y = -327.207;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 592.762;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
        
        Element = SpriteEntity
        {
            Component* Components
            [
                Element = Transform
                {
                    Vec2 rotationOffset
                    {
                        float X = 0;
                        
                        float Y = 0;
                    }
                    
                    Vec2 Scale
                    {
                        float X = 61.8001;
                        
                        float Y = 61.8001;
                    }
                    
                    float Rotation = 1.5;
                    
                    Vec3 Position
                    {
                        float X = 95.6726;
                        
                        float Y = -574.875;
                        
                        float Z = 0;
                    }
                }
                
                Element = Sprite
                {
                    InstanceData InstanceData
                    {
                        Vec2 TexCoordUV
                        {
                            float X = 0;
                            
                            float Y = 0;
                        }
                        
                        Vec2 TexDimension
                        {
                            float X = 1;
                            
                            float Y = 1;
                        }
                        
                        Vec3 wibbleParams2
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = 582.085;
                        }
                        
                        float glowStrength = 1;
                        
                        Vec3 glowColor
                        {
                            float X = 0.607812;
                            
                            float Y = 1.66836;
                            
                            float Z = 0.994531;
                        }
                        
                        Vec3 wibbleParams1
                        {
                            float X = 1;
                            
                            float Y = 0;
                            
                            float Z = -0.01;
                        }
                        
                        float glowAlpha = 1;
                        
                        float wibble = 1;
                    }
                    
                    int LayerID = -1;
                    
                    std::string Texture
                    {
                        char* String = "lightKelp_base.png";
                    }
                    
                    int ShaderType = 7;
                }
            ]
            
            Entity* Children
            [
            ]
        }
    ]
}

