Пример #1
0
        protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
        {
#warning TODO: values acording to read version (current 2017.3.0f3)
            YAMLMappingNode node = base.ExportYAMLRoot(container);
            node.AddSerializedVersion(GetSerializedVersion(container.Version));
            node.Add("m_ClearFlags", ClearFlags);
            node.Add("m_BackGroundColor", BackGroundColor.ExportYAML(container));
            node.Add("m_NormalizedViewPortRect", NormalizedViewPortRect.ExportYAML(container));
            node.Add("near clip plane", NearClipPlane);
            node.Add("far clip plane", FarClipPlane);
            node.Add("field of view", FieldOfView);
            node.Add("orthographic", Orthographic);
            node.Add("orthographic size", OrthographicSize);
            node.Add("m_Depth", Depth);
            node.Add("m_CullingMask", CullingMask.ExportYAML(container));
            node.Add("m_RenderingPath", (int)RenderingPath);
            node.Add("m_TargetTexture", TargetTexture.ExportYAML(container));
            node.Add("m_TargetDisplay", TargetDisplay);
            node.Add("m_TargetEye", (int)TargetEye);
            node.Add("m_HDR", HDR);
            node.Add("m_AllowMSAA", AllowMSAA);
            node.Add("m_AllowDynamicResolution", AllowDynamicResolution);
            node.Add("m_ForceIntoRT", ForceIntoRT);
            node.Add("m_OcclusionCulling", OcclusionCulling);
            node.Add("m_StereoConvergence", StereoConvergence);
            node.Add("m_StereoSeparation", StereoSeparation);
            return(node);
        }
Пример #2
0
        protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
        {
            YAMLMappingNode node = base.ExportYAMLRoot(container);

            node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
            node.Add(TypeName, (int)Type);
            node.Add(ModeName, (int)Mode);
            node.Add(RefreshModeName, (int)RefreshMode);
            node.Add(TimeSlicingModeName, (int)TimeSlicingMode);
            node.Add(ResolutionName, Resolution);
            node.Add(UpdateFrequencyName, UpdateFrequency);
            node.Add(BoxSizeName, BoxSize.ExportYAML(container));
            node.Add(BoxOffsetName, BoxOffset.ExportYAML(container));
            node.Add(NearClipName, NearClip);
            node.Add(FarClipName, FarClip);
            node.Add(ShadowDistanceName, ShadowDistance);
            node.Add(ClearFlagsName, (uint)ClearFlags);
            node.Add(BackGroundColorName, BackGroundColor.ExportYAML(container));
            node.Add(CullingMaskName, CullingMask.ExportYAML(container));
            node.Add(IntensityMultiplierName, IntensityMultiplier);
            node.Add(BlendDistanceName, BlendDistance);
            node.Add(HDRName, HDR);
            node.Add(BoxProjectionName, BoxProjection);
            node.Add(RenderDynamicObjectsName, RenderDynamicObjects);
            node.Add(UseOcclusionCullingName, UseOcclusionCulling);
            node.Add(ImportanceName, Importance);
            node.Add(CustomBakedTextureName, CustomBakedTexture.ExportYAML(container));
            if (IsReadBakedTexture(container.ExportVersion, container.ExportFlags))
            {
                node.Add(BakedTextureName, BakedTextureTexture.ExportYAML(container));
            }
            return(node);
        }
Пример #3
0
        protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
        {
            YAMLMappingNode node = base.ExportYAMLRoot(container);

            node.AddSerializedVersion(GetSerializedVersion(container.Version));
            node.Add(ClearFlagsName, ClearFlags);
            node.Add(BackGroundColorName, BackGroundColor.ExportYAML(container));

            // 2018
            node.Add(ProjectionMatrixModeName, (int)ProjectionMatrixMode);
            node.Add(SensorSizeName, SensorSize.ExportYAML(container));
            node.Add(LensShiftName, LensShift.ExportYAML(container));
            node.Add(FocalLengthName, FocalLength);

            node.Add(NormalizedViewPortRectName, NormalizedViewPortRect.ExportYAML(container));
            node.Add(NearClipPlaneName, NearClipPlane);
            node.Add(FarClipPlaneName, FarClipPlane);
            node.Add(FieldOfViewName, FieldOfView);
            node.Add(OrthographicName, Orthographic);
            node.Add(OrthographicSizeName, OrthographicSize);
            node.Add(DepthName, Depth);
            node.Add(CullingMaskName, CullingMask.ExportYAML(container));
            node.Add(RenderingPathName, (int)RenderingPath);
            node.Add(TargetTextureName, TargetTexture.ExportYAML(container));
            node.Add(TargetDisplayName, TargetDisplay);
            node.Add(TargetEyeName, (int)TargetEye);
            node.Add(HDRName, HDR);
            node.Add(AllowMSAAName, AllowMSAA);
            node.Add(AllowDynamicResolutionName, AllowDynamicResolution);
            node.Add(ForceIntoRTName, ForceIntoRT);
            node.Add(OcclusionCullingName, OcclusionCulling);
            node.Add(StereoConvergenceName, StereoConvergence);
            node.Add(StereoSeparationName, StereoSeparation);
            return(node);
        }
Пример #4
0
    public void BackGroundColorChange(BackGroundColor color)
    {
        Color changecolor = new Color();

        switch (color)
        {
        case BackGroundColor.Fire:
            changecolor.a       = 1;
            changecolor.r       = 0.5f;
            changecolor.g       = 0;
            changecolor.b       = 0.1f;
            backGroundObj.color = changecolor;
            break;

        case BackGroundColor.Ice:
            changecolor.a       = 1;
            changecolor.r       = 0.05f;
            changecolor.g       = 0.1f;
            changecolor.b       = 0.1f;
            backGroundObj.color = changecolor;
            break;

        case BackGroundColor.Thunder:
            backGroundObj.color = Color.black;
            break;

        case BackGroundColor.Esper:
            backGroundObj.color = Color.black;
            break;
        }
    }
Пример #5
0
 public General(string header, GlobalLight globalLight, Fog fog, BackGroundColor backGroundColor, Frustum frustum, DirectionLightAmbient directionLightAmbient, DirectionLightDiffuse directionLightDiffuse)
 {
     Header                = header;
     GlobalLight           = globalLight;
     Fog                   = fog;
     BackGroundColor       = backGroundColor;
     Frustum               = frustum;
     DirectionLightAmbient = directionLightAmbient;
     DirectionLightDiffuse = directionLightDiffuse;
 }
Пример #6
0
        public override int GetHashCode()
        {
            var hashCode = 679998008;

            hashCode = hashCode * -1521134295 + Data.GetHashCode();
            hashCode = hashCode * -1521134295 + TextColor.GetHashCode();
            hashCode = hashCode * -1521134295 + BackGroundColor.GetHashCode();
            hashCode = hashCode * -1521134295 + RePaint.GetHashCode();
            hashCode = hashCode * -1521134295 + Empty.GetHashCode();
            return(hashCode);
        }
Пример #7
0
        public override void Read(AssetStream stream)
        {
            base.Read(stream);

            ClearFlags = stream.ReadUInt32();
            BackGroundColor.Read(stream);
            if (IsReadProjectionMatrixMode(stream.Version))
            {
                ProjectionMatrixMode = (ProjectionMatrixMode)stream.ReadInt32();
                SensorSize.Read(stream);
                LensShift.Read(stream);
                FocalLength = stream.ReadSingle();
            }
            NormalizedViewPortRect.Read(stream);
            NearClipPlane = stream.ReadSingle();
            FarClipPlane  = stream.ReadSingle();
            FieldOfView   = stream.ReadSingle();
            Orthographic  = stream.ReadBoolean();
            stream.AlignStream(AlignType.Align4);

            OrthographicSize = stream.ReadSingle();
            Depth            = stream.ReadSingle();
            CullingMask.Read(stream);
            if (IsReadRenderingPath(stream.Version))
            {
                RenderingPath = (RenderingPath)stream.ReadInt32();
            }
            TargetTexture.Read(stream);
            if (IsReadTargetDisplay(stream.Version))
            {
                TargetDisplay = stream.ReadInt32();
            }
            if (IsReadTargetEye(stream.Version))
            {
                TargetEye = (StereoTargetEyeMask)stream.ReadInt32();
            }
            if (IsReadHDR(stream.Version))
            {
                HDR = stream.ReadBoolean();
            }
            if (IsReadAllowMSAA(stream.Version))
            {
                AllowMSAA = stream.ReadBoolean();
            }
            if (IsReadAllowDynamicResolution(stream.Version))
            {
                AllowDynamicResolution = stream.ReadBoolean();
            }
            if (IsReadForceIntoRT(stream.Version))
            {
                ForceIntoRT = stream.ReadBoolean();
            }
            if (IsReadOcclusionCulling(stream.Version))
            {
                OcclusionCulling = stream.ReadBoolean();
            }
            if (IsAlign(stream.Version))
            {
                stream.AlignStream(AlignType.Align4);
            }
            if (IsReadStereoConvergence(stream.Version))
            {
                StereoConvergence = stream.ReadSingle();
                StereoSeparation  = stream.ReadSingle();
            }
            if (IsReadStereoMirrorMode(stream.Version))
            {
                StereoMirrorMode = stream.ReadBoolean();
            }
        }
Пример #8
0
        public override void Read(AssetReader reader)
        {
            base.Read(reader);

            ClearFlags = reader.ReadUInt32();
            BackGroundColor.Read(reader);
            if (HasProjectionMatrixMode(reader.Version))
            {
                ProjectionMatrixMode = (ProjectionMatrixMode)reader.ReadInt32();
            }
            if (HasGateFitMode(reader.Version))
            {
                if (HasGateFitModeFirst(reader.Version))
                {
                    GateFitMode = (GateFitMode)reader.ReadInt32();
                }
            }
#if UNIVERSAL
            if (HasFOVAxisMode(reader.Version, reader.Flags))
            {
                FOVAxisMode = (FieldOfViewAxis)reader.ReadInt32();
            }
#endif
            if (IsAlign1(reader.Version))
            {
                reader.AlignStream();
            }
            if (HasSensorSize(reader.Version))
            {
                SensorSize.Read(reader);
                LensShift.Read(reader);
            }
            if (HasGateFitMode(reader.Version))
            {
                if (!HasGateFitModeFirst(reader.Version))
                {
                    GateFitMode = (GateFitMode)reader.ReadInt32();
                }
            }
            if (HasFocalLength(reader.Version))
            {
                FocalLength = reader.ReadSingle();
            }

            NormalizedViewPortRect.Read(reader);
            NearClipPlane = reader.ReadSingle();
            FarClipPlane  = reader.ReadSingle();
            FieldOfView   = reader.ReadSingle();
            Orthographic  = reader.ReadBoolean();
            reader.AlignStream();

            OrthographicSize = reader.ReadSingle();
            Depth            = reader.ReadSingle();
            CullingMask.Read(reader);
            if (HasRenderingPath(reader.Version))
            {
                RenderingPath = (RenderingPath)reader.ReadInt32();
            }
            TargetTexture.Read(reader);
            if (HasTargetDisplay(reader.Version))
            {
                TargetDisplay = reader.ReadInt32();
            }
            if (HasTargetEye(reader.Version))
            {
                TargetEye = (StereoTargetEyeMask)reader.ReadInt32();
            }
            if (HasHDR(reader.Version))
            {
                HDR = reader.ReadBoolean();
            }
            if (HasAllowMSAA(reader.Version))
            {
                AllowMSAA = reader.ReadBoolean();
            }
            if (HasAllowDynamicResolution(reader.Version))
            {
                AllowDynamicResolution = reader.ReadBoolean();
            }
            if (HasForceIntoRT(reader.Version))
            {
                ForceIntoRT = reader.ReadBoolean();
            }
            if (HasOcclusionCulling(reader.Version))
            {
                OcclusionCulling = reader.ReadBoolean();
            }
            if (IsAlign2(reader.Version))
            {
                reader.AlignStream();
            }
            if (HasStereoConvergence(reader.Version))
            {
                StereoConvergence = reader.ReadSingle();
                StereoSeparation  = reader.ReadSingle();
            }
            if (HasStereoMirrorMode(reader.Version))
            {
                StereoMirrorMode = reader.ReadBoolean();
            }
        }
Пример #9
0
        public override void Read(AssetReader reader)
        {
            base.Read(reader);

            Type = (ReflectionProbeType)reader.ReadInt32();
            Mode = (ReflectionProbeMode)reader.ReadInt32();
            if (IsReadRefreshMode(reader.Version))
            {
                RefreshMode     = (ReflectionProbeRefreshMode)reader.ReadInt32();
                TimeSlicingMode = (ReflectionProbeTimeSlicingMode)reader.ReadInt32();
            }
            Resolution      = reader.ReadInt32();
            UpdateFrequency = reader.ReadInt32();
            if (IsReadImportance(reader.Version))
            {
                if (IsReadImportanceFirst(reader.Version))
                {
                    Importance = reader.ReadInt16();
                }
            }
            BoxSize.Read(reader);
            BoxOffset.Read(reader);
            NearClip       = reader.ReadSingle();
            FarClip        = reader.ReadSingle();
            ShadowDistance = reader.ReadSingle();
            ClearFlags     = (ReflectionProbeClearFlags)reader.ReadUInt32();
            BackGroundColor.Read(reader);
            CullingMask.Read(reader);
            IntensityMultiplier = reader.ReadSingle();
            if (IsReadBlendDistance(reader.Version))
            {
                BlendDistance = reader.ReadSingle();
            }
            if (IsReadBakedRenderPassCount(reader.Version))
            {
                BakedRenderPassCount = reader.ReadUInt32();
                UseMipMap            = reader.ReadBoolean();
            }
            HDR = reader.ReadBoolean();
            if (IsReadBoxProjection(reader.Version))
            {
                BoxProjection        = reader.ReadBoolean();
                RenderDynamicObjects = reader.ReadBoolean();
                UseOcclusionCulling  = reader.ReadBoolean();
            }
            if (IsReadImportance(reader.Version))
            {
                if (!IsReadImportanceFirst(reader.Version))
                {
                    Importance = reader.ReadInt16();
                }
            }
            reader.AlignStream(AlignType.Align4);

            if (IsReadCustomBakedTexture(reader.Version))
            {
                CustomBakedTexture.Read(reader);
            }
            if (IsReadBakedTexture(reader.Version, reader.Flags))
            {
                BakedTextureTexture.Read(reader);
            }
        }
Пример #10
0
        //Method for starting the app
        public static void start()
        {
            Console.WriteLine("----------------------------");
            Console.WriteLine("Choose one of the following options: ");
            Console.WriteLine("1. Your name \n2. Your name is  \n3. Sum of two values \n4. Calculator \n5. Lottery \n6. Rock Paper Scissor  \n7. Change background color \n8. Guess game \n9. Quiz \n10. Exit the program");
            Console.WriteLine("----------------------------");

            //Switch statement for displaying the menu
            switch (Console.ReadLine())
            {
            case "1":
                Console.Clear();
                name.enterName();
                start();
                break;

            case "2":
                Console.Clear();
                name.getName();
                start();
                break;

            case "3":
                getValues();
                break;

            case "4":
                Console.Clear();
                var calculator = new Calculator();
                calculator.Calculate();
                start();
                break;

            case "5":
                var gamble = new Lottery();
                Console.Clear();
                gamble.start();
                break;

            case "6":
                Console.Clear();
                var rockPaperS = new RockPaperScissors();
                rockPaperS.PlayRockPaperScissors();
                start();
                break;

            case "7":
                Console.Clear();
                var cs = new BackGroundColor();
                cs.ColorChange();
                start();
                break;

            case "8":
                Console.Clear();
                var guessGame = new GuessGame();
                guessGame.Game();
                start();
                break;

            case "9":
                Console.Clear();
                var quiz = new Quiz();
                quiz.PlayQuiz();
                start();
                break;

            case "10":
                Environment.Exit(-1);
                break;

            default:
                Console.Clear();
                Console.WriteLine("That's an invalid input try again! \n");
                start();
                break;
            }
        }