コード例 #1
0
BOOL ShaderProcessor::ProcessShader(CTSTR input)
{
    String curToken;

    BOOL bError = FALSE;

    SetCodeStart(input);

    TSTR lpLastPos = lpTemp;

    DWORD curInsideCount = 0;
    BOOL  bNewCodeLine = TRUE;

    while(GetNextToken(curToken))
    {
        TSTR lpCurPos = lpTemp-curToken.Length();

        if(curToken[0] == '{')
            ++curInsideCount;
        else if(curToken[0] == '}')
            --curInsideCount;
        else if(curToken[0] == '(')
            ++curInsideCount;
        else if(curToken[0] == ')')
            --curInsideCount;
        else if(!curInsideCount && bNewCodeLine) //not inside any code, so this is some sort of declaration (function/struct/var)
        {
            if(curToken == TEXT("struct"))
            {
                //try to see if this is the vertex definition structure
                bool bFoundDefinitionStruct = false;

                HandMeAToken(curToken);
                ExpectTokenIgnore(TEXT("{"));
                curInsideCount = 1;

                do 
                {
                    HandMeAToken(curToken);
                    if(curToken.Length() <= 6 && scmpi_n(curToken, TEXT("float"), 5) == 0)
                    {
                        String strType = curToken;

                        String strName;
                        HandMeAToken(strName);

                        HandMeAToken(curToken);
                        if(curToken[0] != ':') //cancel if not a vertex definition structure
                        {
                            bFoundDefinitionStruct = false;
                            break;
                        }

                        String strSemantic;
                        HandMeAToken(strSemantic);

                        SemanticInfo semanticInfo;
                        if(!GetSemanticInfo(strSemantic, semanticInfo))
                        {
                            bFoundDefinitionStruct = false;
                            break;
                        }

                        D3D10_INPUT_ELEMENT_DESC inputElement;
                        inputElement.SemanticName           = semanticInfo.lpName;
                        inputElement.SemanticIndex          = semanticInfo.index;
                        inputElement.InputSlot              = 0;
                        inputElement.AlignedByteOffset      = 0;
                        inputElement.InputSlotClass         = D3D10_INPUT_PER_VERTEX_DATA;
                        inputElement.InstanceDataStepRate   = 0;

                        if(strSemantic.CompareI(TEXT("color")))
                            inputElement.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                        else
                        {
                            switch(strType[5])
                            {
                                case 0:   inputElement.Format = DXGI_FORMAT_R32_FLOAT;          break;
                                case '2': inputElement.Format = DXGI_FORMAT_R32G32_FLOAT;       break;
                                case '3': inputElement.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; break; //todo: check this some time
                                case '4': inputElement.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
                            }
                        }

                        ExpectToken(TEXT(";"), TEXT(";"));

                        PeekAtAToken(curToken);

                        generatedLayout << inputElement;

                        bFoundDefinitionStruct = true;
                    }
                    else
                    {
                        bFoundDefinitionStruct = false;
                        break; //vertex definition structures should really only ever have float values
                    }
                } while (curToken[0] != '}');

                //set up the slots so they match up with vertex buffers
                if(bFoundDefinitionStruct)
                {
                    UINT curSlot = 0;

                    for(UINT i=0; i<generatedLayout.Num(); i++)
                    {
                        if(stricmp(generatedLayout[i].SemanticName, "SV_Position") == 0)
                        {
                            generatedLayout[i].InputSlot = curSlot++;
                            break;
                        }
                    }

                    for(UINT i=0; i<generatedLayout.Num(); i++)
                    {
                        if(stricmp(generatedLayout[i].SemanticName, "NORMAL") == 0)
                        {
                            generatedLayout[i].InputSlot = curSlot++;
                            bHasNormals = true;
                            break;
                        }
                    }

                    for(UINT i=0; i<generatedLayout.Num(); i++)
                    {
                        if(stricmp(generatedLayout[i].SemanticName, "COLOR") == 0)
                        {
                            generatedLayout[i].InputSlot = curSlot++;
                            bHasColors = true;
                            break;
                        }
                    }

                    for(UINT i=0; i<generatedLayout.Num(); i++)
                    {
                        if(stricmp(generatedLayout[i].SemanticName, "TANGENT") == 0)
                        {
                            generatedLayout[i].InputSlot = curSlot++;
                            bHasTangents = true;
                            break;
                        }
                    }

                    bool bFoundTexCoord;

                    do
                    {
                        bFoundTexCoord = false;

                        for(UINT i=0; i<generatedLayout.Num(); i++)
                        {
                            if(generatedLayout[i].SemanticIndex == numTextureCoords && stricmp(generatedLayout[i].SemanticName, "TEXCOORD") == 0)
                            {
                                generatedLayout[i].InputSlot = curSlot++;
                                numTextureCoords++;
                                bFoundTexCoord = true;
                                break;
                            }
                        }
                    } while(bFoundTexCoord);
                }
            }
            else if( (curToken != TEXT("const"))     &&
                     (curToken != TEXT("void"))      &&
                     (curToken != TEXT(";"))         )
            {
                TSTR lpSavedPos = lpTemp;
                String savedToken = curToken;

                if(curToken == TEXT("uniform"))
                    HandMeAToken(curToken);

                String strType = curToken;

                String strName;
                HandMeAToken(strName);

                PeekAtAToken(curToken);
                if(curToken[0] != '(') //verified variable
                {
                    if(strType.CompareI(TEXT("samplerstate")))
                    {
                        ShaderSampler &curSampler = *Samplers.CreateNew();
                        curSampler.name = strName;

                        SamplerInfo info;

                        ExpectToken(TEXT("{"), TEXT(";"));

                        PeekAtAToken(curToken);

                        while(curToken != TEXT("}"))
                        {
                            String strState;
                            HandMeAToken(strState);

                            ExpectToken(TEXT("="), TEXT(";"));

                            String strValue;
                            HandMeAToken(strValue);

                            if(!AddState(info, strState, strValue))
                                EscapeLikeTheWind(TEXT(";"));

                            ExpectToken(TEXT(";"), TEXT(";"));

                            PeekAtAToken(curToken);
                        }

                        curSampler.sampler = CreateSamplerState(info);

                        ExpectToken(TEXT("}"), TEXT("}"));
                        ExpectTokenIgnore(TEXT(";"));

                        //----------------------------------------

                        lpLastPos = lpTemp;
                        continue;
                    }
                    else
                    {
                        ShaderParam *param = Params.CreateNew();
                        param->name = strName;

                        if(curToken[0] == '[')
                        {
                            HandMeAToken(curToken);

                            HandMeAToken(curToken);
                            param->arrayCount = tstoi(curToken);

                            ExpectToken(TEXT("]"), TEXT(";"));

                            PeekAtAToken(curToken);
                        }

                        if(scmpi_n(strType, TEXT("texture"), 7) == 0)
                        {
                            TSTR lpType = strType.Array()+7;
                            supr(lpType);

                            if (!*lpType ||
                                (scmp(lpType, TEXT("1D")) && scmp(lpType, TEXT("2D")) && scmp(lpType, TEXT("3D")) && scmp(lpType, TEXT("CUBE")))
                                )
                            {
                                bError = TRUE;
                            }

                            param->textureID = nTextures++;
                            param->type = Parameter_Texture;

                            strType = TEXT("sampler");
                        }
                        else if(scmp_n(strType, TEXT("float"), 5) == 0)
                        {
                            CTSTR lpType = strType.Array()+5;

                            if(*lpType == 0)
                                param->type = Parameter_Float;
                            else if(scmpi(lpType, TEXT("2")) == 0)
                                param->type = Parameter_Vector2;
                            else if(scmpi(lpType, TEXT("3")) == 0)
                                param->type = Parameter_Vector3;
                            else if(scmpi(lpType, TEXT("4")) == 0)
                                param->type = Parameter_Vector4;
                            else if(scmpi(lpType, TEXT("3x3")) == 0)
                                param->type = Parameter_Matrix3x3;
                            else if(scmpi(lpType, TEXT("4x4")) == 0)
                                param->type = Parameter_Matrix;
                        }
                        else if(scmp(strType, TEXT("int")) == 0)
                            param->type = Parameter_Int;
                        else if(scmp(strType, TEXT("bool")) == 0)
                            param->type = Parameter_Bool;


                        if(curToken == TEXT("="))
                        {
                            HandMeAToken(curToken);

                            BufferOutputSerializer sOut(param->defaultValue);

                            if(scmp(strType, TEXT("float")) == 0)
                            {
                                HandMeAToken(curToken);

                                if(!ValidFloatString(curToken))
                                    bError = TRUE;

                                float fValue = (float)tstof(curToken);

                                sOut << fValue;
                            }
                            else if(scmp(strType, TEXT("int")) == 0)
                            {
                                HandMeAToken(curToken);

                                if(!ValidIntString(curToken))
                                    bError = TRUE;

                                int iValue = tstoi(curToken);

                                sOut << iValue;
                            }
                            else if(scmp_n(strType, TEXT("float"), 5) == 0)
                            {
                                CTSTR lpFloatType = strType.Array()+5;
                                int floatCount = 0;

                                if(lpFloatType[0] == '1') floatCount = 1;
                                else if(lpFloatType[0] == '2') floatCount = 2;
                                else if(lpFloatType[0] == '3') floatCount = 3;
                                else if(lpFloatType[0] == '4') floatCount = 4;
                                else
                                    bError = TRUE;

                                if(lpFloatType[1] == 'x')
                                {
                                    if(lpFloatType[2] != '1')
                                    {
                                        if(lpFloatType[2] == '2') floatCount *= 2;
                                        else if(lpFloatType[2] == '3') floatCount *= 3;
                                        else if(lpFloatType[2] == '4') floatCount *= 4;
                                        else
                                            bError = TRUE;
                                    }
                                }

                                if(floatCount > 1) {ExpectToken(TEXT("{"), TEXT(";"));}

                                int j;
                                for(j=0; j<floatCount; j++)
                                {
                                    if(j)
                                    {
                                        HandMeAToken(curToken);
                                        if(curToken[0] != ',')
                                        {
                                            bError = TRUE;
                                            break;
                                        }
                                    }

                                    HandMeAToken(curToken);

                                    if(!ValidFloatString(curToken))
                                    {
                                        bError = TRUE;
                                        break;
                                    }

                                    float fValue = (float)tstof(curToken);
                                    sOut << fValue;
                                }

                                if(j != floatCount) //processing error occured
                                {
                                    GotoToken(TEXT(";"));
                                    continue;
                                }

                                if(floatCount > 1)
                                {ExpectToken(TEXT("}"), TEXT(";"));}
                            }

                            PeekAtAToken(curToken);
                        }
                    }

                    //--------------------------

                    lpLastPos = lpTemp;
                    bNewCodeLine = FALSE;
                    continue;
                }

                lpTemp = lpSavedPos;
                curToken = savedToken;
            }
        }

        lpLastPos = lpTemp;

        bNewCodeLine = (curToken.IsValid() && ((curToken[0] == ';') || (curToken[0] == '}')));
    }

    return !bError;
}
コード例 #2
0
ファイル: CodeTokenizer.cpp プロジェクト: AndrewHolder/OBS
BOOL CodeTokenizer::GetNextTokenEval(String &token, BOOL *bFloatOccurance, int curPrecedence)
{
    TSTR lpLastSafePos = lpTemp;
    String curVal, curToken;
    BOOL bFoundNumber = FALSE;
    BOOL bUsedBracers = FALSE;

    if(!GetNextToken(curToken)) return FALSE;

    if(curToken == TEXT("("))
    {
        TSTR lpPrevPos = lpTemp;
        int newPrecedence = GetTokenPrecedence(curToken);
        if(!GetNextTokenEval(curToken, bFloatOccurance, newPrecedence)) return FALSE;

        if(!ValidFloatString(curToken))
        {
            lpTemp = lpPrevPos;
            token = TEXT("(");
            return TRUE;
        }

        String nextToken;
        if(!GetNextToken(nextToken)) return FALSE;
        if(nextToken != TEXT(")"))
        {
            lpTemp = lpPrevPos;
            token = TEXT("(");
            return TRUE;
        }

        bUsedBracers = TRUE;
    }

    if(curToken == TEXT("-") && iswdigit(*lpTemp))
    {
        String nextToken;
        if(!GetNextToken(nextToken)) return FALSE;
        curToken << nextToken;
    }

    if(ValidFloatString(curToken))
    {
        bFoundNumber = TRUE;
        curVal = curToken;

        if(!ValidIntString(curVal) && bFloatOccurance)
            *bFloatOccurance = TRUE;
    }
    else
    {
        if(bFoundNumber)
        {
            lpTemp = lpLastSafePos;
            token = curVal;
            return TRUE;
        }
        else
        {
            token = curToken;
            return TRUE;
        }
    }

    lpLastSafePos = lpTemp;

    String operatorToken;
    while(GetNextToken(operatorToken))
    {
        int newPrecedence = GetTokenPrecedence(operatorToken);
        if(newPrecedence <= curPrecedence)
        {
            lpTemp = lpLastSafePos;
            token = curVal;
            return TRUE;
        }

        String nextVal;
        if(!GetNextTokenEval(nextVal, bFloatOccurance, newPrecedence)) return FALSE;

        if(!ValidFloatString(nextVal))
        {
            lpTemp = lpLastSafePos;
            token = curVal;
            return TRUE;
        }

        if(operatorToken == TEXT("<<"))
        {
            int val1 = tstoi(curVal);
            int val2 = tstoi(nextVal);

            val1 <<= val2;
            curVal = IntString(val1);
        }
        else if(operatorToken == TEXT(">>"))
        {
            int val1 = tstoi(curVal);
            int val2 = tstoi(nextVal);

            val1 >>= val2;
            curVal = IntString(val1);
        }
        else if(operatorToken == TEXT("*"))
コード例 #3
0
BOOL ShaderProcessor::AddState(SamplerInfo &info, String &stateName, String &stateVal)
{
    if(scmpi_n(stateName, TEXT("Address"), 7) == 0)
    {
        int type = stateName[7]-'U';

        GSAddressMode *mode;
        switch(type)
        {
            case 0: mode = &info.addressU; break;
            case 1: mode = &info.addressV; break;
            case 2: mode = &info.addressW; break;
            default: CrashError(TEXT("Invalid shader address type %d"), type);
        }

        if(stateVal.CompareI(TEXT("Wrap")) || stateVal.CompareI(TEXT("Repeat")))
            *mode = GS_ADDRESS_WRAP;
        else if(stateVal.CompareI(TEXT("Clamp")) || stateVal.CompareI(TEXT("None")))
            *mode = GS_ADDRESS_CLAMP;
        else if(stateVal.CompareI(TEXT("Mirror")))
            *mode = GS_ADDRESS_MIRROR;
        else if(stateVal.CompareI(TEXT("Border")))
            *mode = GS_ADDRESS_BORDER;
        else if(stateVal.CompareI(TEXT("MirrorOnce")))
            *mode = GS_ADDRESS_MIRRORONCE;
    }
    else if(stateName.CompareI(TEXT("MaxAnisotropy")))
    {
        info.maxAnisotropy = tstoi(stateVal);
    }
    else if(stateName.CompareI(TEXT("Filter")))
    {
        if(stateVal.CompareI(TEXT("Anisotropic")))
            info.filter = GS_FILTER_ANISOTROPIC;
        else if(stateVal.CompareI(TEXT("Point")) || stateVal.CompareI(TEXT("MIN_MAG_MIP_POINT")))
            info.filter = GS_FILTER_POINT;
        else if(stateVal.CompareI(TEXT("Linear")) || stateVal.CompareI(TEXT("MIN_MAG_MIP_LINEAR")))
            info.filter = GS_FILTER_LINEAR;
        else if(stateVal.CompareI(TEXT("MIN_MAG_POINT_MIP_LINEAR")))
            info.filter = GS_FILTER_MIN_MAG_POINT_MIP_LINEAR;
        else if(stateVal.CompareI(TEXT("MIN_POINT_MAG_LINEAR_MIP_POINT")))
            info.filter = GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
        else if(stateVal.CompareI(TEXT("MIN_POINT_MAG_MIP_LINEAR")))
            info.filter = GS_FILTER_MIN_POINT_MAG_MIP_LINEAR;
        else if(stateVal.CompareI(TEXT("MIN_LINEAR_MAG_MIP_POINT")))
            info.filter = GS_FILTER_MIN_LINEAR_MAG_MIP_POINT;
        else if(stateVal.CompareI(TEXT("MIN_LINEAR_MAG_POINT_MIP_LINEAR")))
            info.filter = GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
        else if(stateVal.CompareI(TEXT("MIN_MAG_LINEAR_MIP_POINT")))
            info.filter = GS_FILTER_MIN_MAG_LINEAR_MIP_POINT;
    }
    else if(stateName.CompareI(TEXT("BorderColor")))
    {
        if(stateVal[0] == '{')
        {
            String curToken;

            HandMeAToken(curToken);
            if(!ValidFloatString(curToken)) {return FALSE;}
            info.borderColor.x = (float)tstof(curToken);

            //-------------------------------

            ExpectToken(TEXT(","));

            //-------------------------------

            HandMeAToken(curToken);
            if(!ValidFloatString(curToken)) {return FALSE;}
            info.borderColor.y = (float)tstof(curToken);

            //-------------------------------

            ExpectToken(TEXT(","));

            //-------------------------------

            HandMeAToken(curToken);
            if(!ValidFloatString(curToken)) {return FALSE;}
            info.borderColor.z = (float)tstof(curToken);

            //-------------------------------

            ExpectToken(TEXT(","));

            //-------------------------------

            HandMeAToken(curToken);
            if(!ValidFloatString(curToken)) {return FALSE;}
            info.borderColor.w = (float)tstof(curToken);

            //-------------------------------

            ExpectToken(TEXT("}"));
        }
        else if(ValidIntString(stateVal))
            info.borderColor = Color4().MakeFromRGBA(tstoi(stateVal));
    }

    return TRUE;
}