コード例 #1
0
ファイル: ShaderParser.cs プロジェクト: terrynoya/DigitalRune
        /// <summary>
        /// Identifies the source code region at the given offset.
        /// </summary>
        /// <param name="document">The document.</param>
        /// <param name="targetOffset">The target offset where the region shall be evaluated.</param>
        /// <returns>The identified source code region.</returns>
        public ShaderRegion IdentifyRegion(ITextSource document, int targetOffset)
        {
            // Parse file from start (offset == 0).
            ShaderRegion region = IdentifyRegion(document, 0, targetOffset, null, null);

            return((region == ShaderRegion.Default) ? ShaderRegion.Global : region);
        }
コード例 #2
0
        /// <summary>
        /// Gets the lookup tables that provide the insight info.
        /// </summary>
        /// <param name="region">The shader region.</param>
        /// <returns>The lookup tables for the specified region.</returns>
        private NamedObjectCollection <NamedCompletionData>[] GetInsightLookupTables(ShaderRegion region)
        {
            NamedObjectCollection <NamedCompletionData>[] lookupTables;

            switch (region)
            {
            case ShaderRegion.Default:
            case ShaderRegion.Global:
                lookupTables = new[] { Functions, Methods, EffectFunctions };
                break;

            case ShaderRegion.StructureOrInterface:
            case ShaderRegion.Code:
                lookupTables = new[] { Functions, Methods };
                break;

            case ShaderRegion.TechniqueOrPass:
            case ShaderRegion.TechniqueOrPass10:
                lookupTables = new[] { EffectFunctions };
                break;

            default:
                lookupTables = null;
                break;
            }
            return(lookupTables);
        }
コード例 #3
0
ファイル: ShaderParser.cs プロジェクト: terrynoya/DigitalRune
        /// <summary>
        /// Identifies the source code region at the given offset and collect all identifiers up to this
        /// offset.
        /// </summary>
        /// <param name="document">The document.</param>
        /// <param name="targetOffset">The target offset where the region shall be evaluated.</param>
        /// <param name="collectedIdentifiers">The collected identifiers.</param>
        /// <param name="collectedFields">The collected field identifiers.</param>
        /// <returns>The identified source code region.</returns>
        /// <remarks>
        /// The method returns the identified source code region. While parsing the source code up to
        /// <paramref name="targetOffset"/> it collects all unknown identifiers in
        /// <paramref name="collectedIdentifiers"/> and all identifiers that look like fields of structs
        /// in <paramref name="collectedFields"/>.
        /// </remarks>
        public ShaderRegion IdentifyRegion(ITextSource document, int targetOffset, out IList <NamedCompletionData> collectedIdentifiers, out IList <NamedCompletionData> collectedFields)
        {
            NamedObjectCollection <NamedCompletionData> identifiers = new NamedObjectCollection <NamedCompletionData>();
            NamedObjectCollection <NamedCompletionData> fields      = new NamedObjectCollection <NamedCompletionData>();

            // Parse file from start (offset == 0).
            ShaderRegion region = IdentifyRegion(document, 0, targetOffset, identifiers, fields);

            collectedIdentifiers = identifiers;
            collectedFields      = fields;
            return((region == ShaderRegion.Default) ? ShaderRegion.Global : region);
        }
コード例 #4
0
        /// <summary>
        /// Gets the lookup-tables that provide the tooltip info.
        /// </summary>
        /// <param name="region">The region of the shader file.</param>
        /// <returns>The lookup-table containing the symbols for the given region.</returns>
        private NamedObjectCollection <NamedCompletionData>[] GetToolTipLookupTables(ShaderRegion region)
        {
            NamedObjectCollection <NamedCompletionData>[] lookupTables;

            switch (region)
            {
            case ShaderRegion.Default:
            case ShaderRegion.Global:
                lookupTables = new[] { Functions, Methods, EffectFunctions, Macros };
                break;

            case ShaderRegion.StructureOrInterface:
            case ShaderRegion.Code:
                lookupTables = new[] { Functions, Methods, Macros };
                break;

            case ShaderRegion.TechniqueOrPass:
            case ShaderRegion.TechniqueOrPass10:
                lookupTables = new[] { EffectFunctions, EffectStates, Macros };
                break;

            case ShaderRegion.BlendState10:
                lookupTables = new[] { BlendStates, EffectStates, Macros };
                break;

            case ShaderRegion.DepthStencilState10:
                lookupTables = new[] { DepthStencilStates, EffectStates, Macros };
                break;

            case ShaderRegion.RasterizerState10:
                lookupTables = new[] { RasterizerStates, EffectStates, Macros };
                break;

            case ShaderRegion.SamplerState:
                lookupTables = new[] { SamplerStates, EffectStates, Macros };
                break;

            case ShaderRegion.SamplerState10:
                lookupTables = new[] { SamplerStates10, EffectStates, Macros };
                break;

            case ShaderRegion.StateBlock:
                lookupTables = new[] { EffectStates, Macros };
                break;

            default:
                lookupTables = null;
                break;
            }
            return(lookupTables);
        }
コード例 #5
0
        private void OnTextEditorMouseHover(object sender, MouseEventArgs eventArgs)
        {
            // Find offset under mouse cursor.
            var        mousePos       = eventArgs.GetPosition(_textEditor.TextArea.TextView);
            double     verticalOffset = _textEditor.VerticalOffset;
            VisualLine visualLine     = _textEditor.TextArea.TextView.GetVisualLineFromVisualTop(mousePos.Y + verticalOffset);

            if (visualLine == null)
            {
                return;
            }

            double horizontalOffset = _textEditor.HorizontalOffset;
            int    visualColumn     = visualLine.GetVisualColumn(mousePos + new Vector(horizontalOffset, verticalOffset));
            int    relativeOffset   = visualLine.GetRelativeOffset(visualColumn);
            int    offset           = visualLine.FirstDocumentLine.Offset + relativeOffset;

            // Get word at mouse cursor.
            var text = TextUtilities.GetIdentifierAt(_textEditor.Document, offset);

            // Get region at mouse cursor.
            ShaderRegion region = _parser.IdentifyRegion(_textEditor.Document, offset);

            NamedObjectCollection <NamedCompletionData>[] lookupTables = GetToolTipLookupTables(region);
            if (lookupTables != null)
            {
                // Look up symbol in lookup tables.
                NamedCompletionData info = null;
                foreach (NamedObjectCollection <NamedCompletionData> lookupTable in lookupTables)
                {
                    if (lookupTable.TryGet <NamedCompletionData>(text, out info))
                    {
                        break;
                    }
                }

                // Show tooltip if lookup was successful and description for the symbol is available.
                if (info != null && !string.IsNullOrEmpty(info.Description as string))
                {
                    // TODO: Use s better tooltip style.
                    _toolTip = new ToolTip
                    {
                        Content   = info.Description,
                        Placement = PlacementMode.Mouse,
                        IsOpen    = true,
                    };
                }
            }
        }
コード例 #6
0
ファイル: ShaderParser.cs プロジェクト: terrynoya/DigitalRune
        public bool IsStateGroup(ShaderRegion region)
        {
            switch (region)
            {
            case ShaderRegion.SamplerState:
            case ShaderRegion.StateBlock:
            case ShaderRegion.TechniqueOrPass:
            case ShaderRegion.BlendState10:
            case ShaderRegion.DepthStencilState10:
            case ShaderRegion.RasterizerState10:
            case ShaderRegion.SamplerState10:
            case ShaderRegion.TechniqueOrPass10:
                return(true);

            default:
                return(false);
            }
        }
コード例 #7
0
ファイル: ShaderParser.cs プロジェクト: terrynoya/DigitalRune
        /// <summary>
        /// Identifies the source code region at the given offset.
        /// </summary>
        /// <param name="document">The document.</param>
        /// <param name="startOffset">The start offset where to start the search.</param>
        /// <param name="targetOffset">The target offset where the region shall be evaluated.</param>
        /// <param name="identifiers">The collected identifiers.</param>
        /// <param name="fields">The collected field identifiers.</param>
        /// <returns>
        /// The method returns the identified source code region.
        /// </returns>
        /// <remarks>
        /// <para>
        /// If there is no region at <paramref name="targetOffset"/> the method returns
        /// <see cref="ShaderRegion.Default"/>. In this the caller needs to decide what region it
        /// actually is. (When <see cref="IdentifyRegion(ITextSource,int,int,NamedObjectCollection{NamedCompletionData},NamedObjectCollection{NamedCompletionData})"/>
        /// is called with a <paramref name="startOffset"/> of 0 then it is <see cref="ShaderRegion.Global"/>.)
        /// </para>
        /// <para>
        /// This method calls itself recursively. First identifies the outermost region, then it
        /// recursively refines the search and returns the innermost region.
        /// </para>
        /// </remarks>
        private ShaderRegion IdentifyRegion(ITextSource document, int startOffset, int targetOffset, NamedObjectCollection <NamedCompletionData> identifiers, NamedObjectCollection <NamedCompletionData> fields)
        {
            int  offset             = startOffset;
            bool collectIdentifiers = (identifiers != null);

            while (offset < document.TextLength && offset < targetOffset)
            {
                char c = document.GetCharAt(offset);
                switch (c)
                {
                case '/':
                    // Skip comments
                    if (offset + 1 < document.TextLength)
                    {
                        char nextChar = document.GetCharAt(offset + 1);
                        if (nextChar == '/')
                        {
                            // Line comment
                            offset = SkipLineComment(document, offset + 2);
                            if (targetOffset <= offset)
                            {
                                return(ShaderRegion.LineComment);
                            }
                        }
                        else if (nextChar == '*')
                        {
                            // Block comment
                            offset = SkipBlockComment(document, offset + 2);
                            if (targetOffset < offset)
                            {
                                return(ShaderRegion.BlockComment);
                            }
                        }
                        else
                        {
                            // No comment
                            ++offset;
                        }
                    }
                    else
                    {
                        // End of file -> Skip past end to terminate algorithm.
                        ++offset;
                    }
                    break;

                case '"':
                    // Skip strings
                    offset = SkipString(document, offset + 1);
                    if (targetOffset < offset)
                    {
                        return(ShaderRegion.String);
                    }
                    break;

                case '\'':
                    // Skip character literals
                    offset = SkipCharacterLiteral(document, offset + 1);
                    if (targetOffset < offset)
                    {
                        return(ShaderRegion.CharacterLiteral);
                    }
                    break;

                case '{':
                    // Identify the current block
                    int          startOffsetOfBlock = offset;
                    ShaderRegion region             = IdentifyBlockAt(document, offset);
                    offset = TextUtilities.FindClosingBracket(document, offset + 1, '{', '}');
                    if (offset == -1 || targetOffset < offset)
                    {
                        // Let's identify the region inside this block. (Recursion!)
                        ShaderRegion innerRegion = IdentifyRegion(document, startOffsetOfBlock + 1, targetOffset, identifiers, fields);
                        if (region == ShaderRegion.TechniqueOrPass10 && innerRegion == ShaderRegion.TechniqueOrPass)
                        {
                            // Return the more specific
                            return(ShaderRegion.TechniqueOrPass10);
                        }
                        if (innerRegion == ShaderRegion.Default || innerRegion == ShaderRegion.Unknown)
                        {
                            // The inner region is unknown or same as outer region
                            return(region);
                        }
                        // Return the more specific inner region.
                        return(innerRegion);
                    }
                    ++offset;
                    break;

                case '<':
                    // Check whether this is an annotation
                    if (IsStartOfAnnotation(document, offset))
                    {
                        int startOffsetOfAnnotation = offset;
                        offset = TextUtilities.FindClosingBracket(document, offset + 1, '<', '>');
                        if (offset == -1 || targetOffset <= offset)
                        {
                            // Let's identify the region inside the annotation. (Recursion!)
                            ShaderRegion innerRegion = IdentifyRegion(document, startOffsetOfAnnotation + 1, targetOffset, identifiers, fields);
                            if (innerRegion == ShaderRegion.Default || innerRegion == ShaderRegion.Unknown)
                            {
                                // The inner region is unknown or same as outer region
                                return(ShaderRegion.Annotation);
                            }

                            // Return the more specific inner region.
                            return(innerRegion);
                        }
                        ++offset;
                    }
                    else
                    {
                        ++offset;
                    }
                    break;

                default:
                    if (Char.IsLetter(c) || c == '_')
                    {
                        if (collectIdentifiers)
                        {
                            string identifier = TextUtilities.GetIdentifierAt(document, offset);
                            if (!String.IsNullOrEmpty(identifier) && !_intelliSense.FullLookupTable.Contains(identifier))
                            {
                                if (offset > 0 && document.GetCharAt(offset - 1) == '.')
                                {
                                    if (!fields.Contains(identifier))
                                    {
                                        fields.Add(new GuessCompletionData(identifier));
                                    }
                                }
                                else
                                {
                                    if (!identifiers.Contains(identifier))
                                    {
                                        identifiers.Add(new GuessCompletionData(identifier));
                                    }
                                }
                            }
                        }
                        offset = SkipIdentifier(document, offset);
                    }
                    else if (Char.IsDigit(c))
                    {
                        offset = SkipNumber(document, offset);
                        if (targetOffset <= offset)
                        {
                            return(ShaderRegion.Default);
                        }
                    }
                    else
                    {
                        ++offset;
                    }
                    break;
                }
            }
            return(ShaderRegion.Default);
        }
コード例 #8
0
        /// <summary>
        /// Requests the insight window.
        /// </summary>
        /// <param name="key">
        /// The currently pressed key which is not yet inserted in the document.
        /// </param>
        /// <remarks>
        /// This method should be called whenever the user types a new character.
        /// </remarks>
        private void RequestInsightWindow(char key)
        {
            // The insight window is shown when '(' or a ',' of a function signature is typed.
            if (key != '(' && key != ',')
            {
                return;
            }

            // Identify the region at the cursor position
            var          document    = _textEditor.Document;
            int          caretOffset = _textEditor.TextArea.Caret.Offset;
            ShaderRegion region      = _parser.IdentifyRegion(document, caretOffset);

            // Fetch lookup tables for the given region.
            NamedObjectCollection <NamedCompletionData>[] lookupTables = GetInsightLookupTables(region);
            if (lookupTables == null)
            {
                return;
            }

            // Find the name of the function.
            int offset = caretOffset;

            if (offset == 0)
            {
                return;
            }

            string identifier = null;

            if (key == '(')
            {
                // Code should look like this:
                //   "Function|"
                int startOfIdentifier = TextUtilities.FindStartOfIdentifier(document, offset - 1);
                if (startOfIdentifier >= 0)
                {
                    identifier = document.GetText(startOfIdentifier, offset - startOfIdentifier);
                }
            }
            else if (key == ',')
            {
                // Check whether we are inside a parameter list.
                //   "Function(param1, param2|"
                offset     = TextUtilities.FindOpeningBracket(document, offset - 1, '(', ')');
                identifier = TextUtilities.GetIdentifierAt(document, offset - 1);
            }

            // Fetch the function description.
            FunctionCompletionData function = null;

            if (!string.IsNullOrEmpty(identifier))
            {
                foreach (NamedObjectCollection <NamedCompletionData> lookupTable in lookupTables)
                {
                    if (lookupTable.TryGet(identifier, out function))
                    {
                        break;
                    }
                }
            }

            ShowOverloadInsightWindow(function);
        }
コード例 #9
0
        /// <summary>
        /// Requests the completion window.
        /// </summary>
        /// <param name="key">The last typed character that was not yet inserted in the document or '\0'.</param>
        /// <param name="explicitRequest">
        /// If set to <see langword="true"/> this is an explicit request to show the window; if <see langword="false"/>
        /// the user is typing.
        /// </param>
        private void RequestCompletionWindow(char key, bool explicitRequest)
        {
            // ----- Determine ShaderRegion of current caret position.
            var document    = _textEditor.Document;
            int caretOffset = _textEditor.CaretOffset;

            IList <NamedCompletionData> collectedIdentifiers;
            IList <NamedCompletionData> collectedFields;
            ShaderRegion region = _parser.IdentifyRegion(document, caretOffset, out collectedIdentifiers, out collectedFields);

            // ----- Abort if current region has no IntelliSense.
            switch (region)
            {
            case ShaderRegion.Unknown:
            case ShaderRegion.Assembler:
            case ShaderRegion.LineComment:
            case ShaderRegion.BlockComment:
            case ShaderRegion.String:
            case ShaderRegion.CharacterLiteral:
                // No IntelliSense for these regions.
                return;
            }

            // ----- # --> PreprocessorCompletionData
            if (key == '#')
            {
                char characterBeforeHash = (caretOffset > 0) ? document.GetCharAt(caretOffset - 1) : '\0';
                if (characterBeforeHash == '\0' || char.IsWhiteSpace(characterBeforeHash))
                {
                    ShowCompletionWindow(PreprocessorCompletionData, null, '#');
                }
                return;
            }

            // ----- Abort if a key is set and it is not part of an identifier.
            bool letterDigitOrUnderscorePressed = (TextUtilities.GetCharacterClass(key) == CharacterClass.IdentifierPart);

            if (key != '\0' && !letterDigitOrUnderscorePressed)
            {
                _completionWindow?.Close();
                return;
            }

            // ----- Find the symbol immediately before the caret.
            string symbol;
            int    offset = TextUtilities.FindStartOfIdentifier(document, caretOffset - 1);

            if (offset >= 0)
            {
                symbol = document.GetText(offset, caretOffset - offset);
            }
            else
            {
                symbol = string.Empty;
                offset = caretOffset;
            }

            // ----- Find the character before the symbol.
            --offset;
            char previousCharacter = (offset >= 0) ? document.GetCharAt(offset) : '\0';

            // ----- #xxxx --> PreprocessorCompletionData
            // Check for preprocessor directives
            if (previousCharacter == '#')
            {
                --offset;
                char characterBeforeHash = (0 <= offset) ? document.GetCharAt(offset) : '\0';
                if (characterBeforeHash == '\0' || char.IsWhiteSpace(characterBeforeHash))
                {
                    symbol = '#' + symbol;
                    ShowCompletionWindow(PreprocessorCompletionData, symbol, key);
                }
                return;
            }

            // ----- xxxxx. --> MemberCompletionData and guessed fields.
            // Check for object members such as "myTexture.|"
            if (previousCharacter == '.')
            {
                if (region == ShaderRegion.StructureOrInterface || region == ShaderRegion.Code)
                {
                    --offset;
                    bool showCompletionWindow = false;
                    char characterBeforeDot   = (0 <= offset) ? document.GetCharAt(offset) : '\0';
                    if (characterBeforeDot == ']' || characterBeforeDot == ')')
                    {
                        // Looks like something similar to "myArray[n].|" or "GetTexture(n).|".
                        // We assume that a member is requested.
                        showCompletionWindow = true;
                    }
                    else
                    {
                        // Check if we have something like "myVariable.|"
                        string objectName = TextUtilities.GetIdentifierAt(document, offset);
                        if (!string.IsNullOrEmpty(objectName) && !Keywords.Contains(objectName) && !_parser.IsType(objectName))
                        {
                            showCompletionWindow = true;
                        }
                    }
                    if (showCompletionWindow)
                    {
                        ShowCompletionWindow(MergeCompletionData(MemberCompletionData, collectedFields), symbol, key);
                    }
                }
                return;
            }

            // ----- Get non-whitespace character before symbol.
            char previousNonWhitespaceChar = previousCharacter;

            if (char.IsWhiteSpace(previousNonWhitespaceChar) && offset > 0)
            {
                offset = _parser.SkipWhiteSpaceBackwards(document, offset - 1);
                previousNonWhitespaceChar = document.GetCharAt(offset);
            }

            // ----- Check for effect state assignments
            if (previousNonWhitespaceChar == '=' && _parser.IsStateGroup(region))
            {
                // The line should look like this:
                //   "EffectState = |"

                --offset;
                offset = _parser.SkipWhiteSpaceBackwards(document, offset);

                // Skip index
                if (document.GetCharAt(offset) == ']')
                {
                    offset = TextUtilities.FindOpeningBracket(document, offset - 1, '[', ']') - 1;
                }

                string stateName = TextUtilities.GetIdentifierAt(document, offset);
                if (!string.IsNullOrEmpty(stateName))
                {
                    // Lookup the state and show the allowed values.
                    NamedObjectCollection <NamedCompletionData> lookupTable = null;
                    switch (region)
                    {
                    case ShaderRegion.BlendState10:
                        lookupTable = BlendStates;
                        break;

                    case ShaderRegion.DepthStencilState10:
                        lookupTable = DepthStencilStates;
                        break;

                    case ShaderRegion.RasterizerState10:
                        lookupTable = RasterizerStates;
                        break;

                    case ShaderRegion.SamplerState:
                        lookupTable = SamplerStates;
                        break;

                    case ShaderRegion.SamplerState10:
                        lookupTable = SamplerStates10;
                        break;

                    case ShaderRegion.TechniqueOrPass:
                    case ShaderRegion.TechniqueOrPass10:
                    case ShaderRegion.StateBlock:
                        lookupTable = EffectStates;
                        break;

                    default:
                        break;
                    }

                    NamedCompletionData state;
                    if (lookupTable != null && lookupTable.TryGet(stateName, out state))
                    {
                        List <NamedCompletionData> stateValueCompletionData;
                        string[] values = ((StateCompletionData)state).AllowedValues;
                        if (values.Length > 0)
                        {
                            // Add the allowed values for this state to completion data.
                            stateValueCompletionData = new List <NamedCompletionData>(values.Length);
                            foreach (string value in values)
                            {
                                stateValueCompletionData.Add(EffectStateValues[value]);
                            }
                        }
                        else
                        {
                            // This effect state has a generic parameter.
                            // Add types ("bool", "int", etc.) to the completion data.
                            stateValueCompletionData = new List <NamedCompletionData>(ScalarTypes.Count + Types.Count);
                            foreach (NamedCompletionData type in ScalarTypes)
                            {
                                stateValueCompletionData.Add(type);
                            }
                            foreach (NamedCompletionData type in Types)
                            {
                                stateValueCompletionData.Add(type);
                            }
                        }

                        // Add the collected identifiers
                        foreach (NamedCompletionData collectedIdentifier in collectedIdentifiers)
                        {
                            stateValueCompletionData.Add(collectedIdentifier);
                        }

                        ShowCompletionWindow(stateValueCompletionData.ToArray(), symbol, key);
                        return;
                    }
                }
            }

            // If we know nothing about the key, and we are after a blank, we don't want to open
            // a completion window.
            // If we have a completion window, we want to continue.
            // If the user has explicitly request info (e.g. Ctrl+Space) we want to continue.
            if (key == '\0' && previousCharacter == ' ' && !explicitRequest && _completionWindow == null)
            {
                return;
            }

            // Show default completion data for each region.
            ICompletionData[] completionData;
            switch (region)
            {
            case ShaderRegion.Global:
                completionData = GlobalCompletionData;
                break;

            case ShaderRegion.StructureOrInterface:
            case ShaderRegion.Code:
                completionData = CodeCompletionData;
                break;

            case ShaderRegion.Annotation:
                completionData = AnnotationCompletionData;
                break;

            case ShaderRegion.TechniqueOrPass:
            case ShaderRegion.TechniqueOrPass10:
                completionData = TechniqueCompletionData;
                break;

            case ShaderRegion.BlendState10:
                completionData = BlendStateCompletionData;
                break;

            case ShaderRegion.DepthStencilState10:
                completionData = DepthStencilStateCompletionData;
                break;

            case ShaderRegion.RasterizerState10:
                completionData = RasterizerStateCompletionData;
                break;

            case ShaderRegion.SamplerState:
                completionData = SamplerStateCompletionData;
                break;

            case ShaderRegion.SamplerState10:
                completionData = SamplerState10CompletionData;
                break;

            case ShaderRegion.StateBlock:
                completionData = StateBlockCompletionData;
                break;

            default:
                completionData = null;
                break;
            }

            // No data --> close window.
            if (completionData == null)
            {
                _completionWindow?.Close();
                return;
            }

            // Combine static completion data with guessed identifiers
            List <ICompletionData> entireCompletionData = new List <ICompletionData>();

            foreach (ICompletionData completionEntry in completionData)
            {
                entireCompletionData.Add(completionEntry);
            }
            foreach (NamedCompletionData collectedIdentifier in collectedIdentifiers)
            {
                entireCompletionData.Add(collectedIdentifier);
            }

            // Show completion window
            ShowCompletionWindow(MergeCompletionData(completionData, collectedIdentifiers), symbol, key);
        }
コード例 #10
0
 public bool IsStateGroup(ShaderRegion region)
 {
     switch (region)
     {
         case ShaderRegion.SamplerState:
         case ShaderRegion.StateBlock:
         case ShaderRegion.TechniqueOrPass:
         case ShaderRegion.BlendState10:
         case ShaderRegion.DepthStencilState10:
         case ShaderRegion.RasterizerState10:
         case ShaderRegion.SamplerState10:
         case ShaderRegion.TechniqueOrPass10:
             return true;
         default:
             return false;
     }
 }
コード例 #11
0
        /// <summary>
        /// Gets the lookup-tables that provide the tooltip info.
        /// </summary>
        /// <param name="region">The region of the shader file.</param>
        /// <returns>The lookup-table containing the symbols for the given region.</returns>
        private NamedObjectCollection<NamedCompletionData>[] GetToolTipLookupTables(ShaderRegion region)
        {
            NamedObjectCollection<NamedCompletionData>[] lookupTables;

            switch (region)
            {
                case ShaderRegion.Default:
                case ShaderRegion.Global:
                    lookupTables = new[] { Functions, Methods, EffectFunctions, Macros };
                    break;

                case ShaderRegion.StructureOrInterface:
                case ShaderRegion.Code:
                    lookupTables = new[] { Functions, Methods, Macros };
                    break;

                case ShaderRegion.TechniqueOrPass:
                case ShaderRegion.TechniqueOrPass10:
                    lookupTables = new[] { EffectFunctions, EffectStates, Macros };
                    break;

                case ShaderRegion.BlendState10:
                    lookupTables = new[] { BlendStates, EffectStates, Macros };
                    break;

                case ShaderRegion.DepthStencilState10:
                    lookupTables = new[] { DepthStencilStates, EffectStates, Macros };
                    break;

                case ShaderRegion.RasterizerState10:
                    lookupTables = new[] { RasterizerStates, EffectStates, Macros };
                    break;

                case ShaderRegion.SamplerState:
                    lookupTables = new[] { SamplerStates, EffectStates, Macros };
                    break;

                case ShaderRegion.SamplerState10:
                    lookupTables = new[] { SamplerStates10, EffectStates, Macros };
                    break;

                case ShaderRegion.StateBlock:
                    lookupTables = new[] { EffectStates, Macros };
                    break;

                default:
                    lookupTables = null;
                    break;
            }
            return lookupTables;
        }
コード例 #12
0
        /// <summary>
        /// Gets the lookup tables that provide the insight info.
        /// </summary>
        /// <param name="region">The shader region.</param>
        /// <returns>The lookup tables for the specified region.</returns>
        private NamedObjectCollection<NamedCompletionData>[] GetInsightLookupTables(ShaderRegion region)
        {
            NamedObjectCollection<NamedCompletionData>[] lookupTables;

            switch (region)
            {
                case ShaderRegion.Default:
                case ShaderRegion.Global:
                    lookupTables = new[] { Functions, Methods, EffectFunctions };
                    break;
                case ShaderRegion.StructureOrInterface:
                case ShaderRegion.Code:
                    lookupTables = new[] { Functions, Methods };
                    break;
                case ShaderRegion.TechniqueOrPass:
                case ShaderRegion.TechniqueOrPass10:
                    lookupTables = new[] { EffectFunctions };
                    break;
                default:
                    lookupTables = null;
                    break;
            }
            return lookupTables;
        }