Esempio n. 1
0
 internal virtual void ProcessProperty(int index, LineTypes.Property line, IParentObject obj, Stack <GameObject> objectStack, ParserContext context)
 {
     // overload with switch-case and handle functionalities
     throw new Exception("Invalid member in parsed lines list");
 }
Esempio n. 2
0
        internal void ObjectProcessProperty(int index, LineTypes.Property line, IParentObject obj, Stack <GameObject> objectStack, ParserContext context)
        {
            #region Object context
            if (context == this.objectContext)
            {
                // properties for object itself (none atm)
                // return;
            }
            #endregion

            #region Transform
            if (context == this.objectContext.Components[0].context)
            {
                switch (index)
                {
                case 0:     // position
                    objectStack.Peek().transform.localPosition = (Vector3)line.argumentsData[0];
                    return;

                case 1:     // rotation
                    objectStack.Peek().transform.localRotation = Quaternion.Euler((Vector3)line.argumentsData[0]);
                    return;

                case 2:     // scale
                    objectStack.Peek().transform.localScale = (Vector3)line.argumentsData[0];
                    return;
                }
            }
            #endregion

            #region Renderer
            if (context == this.objectContext.Components[1].context)
            {
                MeshRenderer renderer = objectStack.Peek().GetComponent <MeshRenderer>();

                switch (index)
                {
                case 0:     // texture
                    renderer.sharedMaterial.SetTexture(line.argumentsData[0].ToString(), (Texture2D)line.argumentsData[1]);
                    return;

                case 1:     // texture scale
                    renderer.sharedMaterial.SetTextureScale(line.argumentsData[0].ToString(), (Vector2)line.argumentsData[1]);
                    return;

                case 2:     // texture offset
                    renderer.sharedMaterial.SetTextureOffset(line.argumentsData[0].ToString(), (Vector2)line.argumentsData[1]);
                    return;

                case 3:     // color
                    renderer.sharedMaterial.SetColor(line.argumentsData[0].ToString(), (Color)line.argumentsData[1]);
                    return;

                case 4:     // shader
                    renderer.sharedMaterial = new Material(Shader.Find(line.argumentsData[0].ToString()));
                    return;

                case 5:     // rendering mode
                    string mode = line.argumentsData[0].ToString().Trim().ToLower();
                    switch (mode)
                    {
                    case "opaque":
                        renderer.sharedMaterial.SetFloat("_Mode", 0);
                        break;

                    case "cutout":
                        renderer.sharedMaterial.SetFloat("_Mode", 1);
                        break;

                    case "fade":
                        renderer.sharedMaterial.SetFloat("_Mode", 2);
                        break;

                    case "transparent":
                        renderer.sharedMaterial.SetFloat("_Mode", 3);
                        break;

                    default:
                        throw new ParserExceptions.ParserEnumException(mode, "Opaque", "Cutout", "Fade", "Transparent");
                    }
                    return;

                default:
                    throw new Exception("Invalid member in parsed lines list");
                }
            }
            #endregion

            // todo: other contexts

            throw new Exception("Invalid member in parsed lines list");
        }
Esempio n. 3
0
        private void ProcessLine(IParentObject rootObject, Stack <ParserContext> contextStack, Stack <GameObject> objectStack, IParserLine tempLine)
        {
            LineType      type           = tempLine.GetType();
            ParserContext currentContext = contextStack.Peek();

            int index = -1;

            switch (type)
            {
            case LineType.Property:
                LineTypes.Property lineProperty = (LineTypes.Property)tempLine;

                for (int i = 0; i < currentContext.Properties.Length; i++)
                {
                    if (currentContext.Properties[i].name == lineProperty.name)
                    {
                        index = i;
                        break;
                    }
                }
                if (index == -1)
                {
                    throw new Exception("Invalid member in parsed lines list");
                }
                ProcessProperty(index, lineProperty, rootObject, objectStack, currentContext);
                break;

            case LineType.Component:
                LineTypes.Component lineComponent = (LineTypes.Component)tempLine;

                for (int i = 0; i < currentContext.Components.Length; i++)
                {
                    if (currentContext.Components[i].name == lineComponent.name)
                    {
                        index = i;
                        break;
                    }
                }
                if (index == -1)
                {
                    throw new Exception("Invalid member in parsed lines list");
                }
                ProcessComponent(index, lineComponent, rootObject, objectStack, contextStack, currentContext);
                contextStack.Push(currentContext.Components[index].context);
                break;

            case LineType.Object:
                LineTypes.Object lineObject = (LineTypes.Object)tempLine;

                GameObject tempGO = new GameObject();
                tempGO.name = lineObject.name;
                tempGO.SetActive(false);

                if (objectStack.Count > 0)
                {
                    tempGO.transform.parent = objectStack.Peek().transform;
                }
                rootObject.AssignChild(tempGO);

                objectStack.Push(tempGO);
                contextStack.Push(this.objectContext);
                break;

            case LineType.ObjectClose:
            case LineType.ComponentClose:
                contextStack.Pop();
                break;

            default:
                throw new System.Exception("Invalid line type in parsed lines list");
            }
        }