std::string GMakeMainFragmentShader( void ) { std::vector< std::string > sourceLines = { DeclPrecision(), DeclGammaConstant(), DeclTransferVar( "frag_Color", "vec4", "in" ), DeclTransferVar( "frag_Tex", "vec2", "in" ), DeclTransferVar( "frag_Lightmap", "vec2", "in" ), "uniform sampler2D mainImageSampler;", "uniform vec2 mainImageImageScaleRatio;", "uniform vec4 mainImageImageTransform;", "uniform sampler2D lightmapSampler;", "uniform vec2 lightmapImageScaleRatio;", "uniform vec4 lightmapImageTransform;", #ifdef G_USE_GL_CORE DeclTransferVar( "fragment", "vec4", "out" ), #endif "void main(void) {", "\tvec2 texCoords;", "\tvec4 image, lightmap, color;", SampleFromTexture( "texCoords", "image", "frag_Tex", "mainImageSampler", "mainImageImageScaleRatio", "mainImageImageTransform" ), SampleFromTexture( "texCoords", "lightmap", "frag_Lightmap", "lightmapSampler", "lightmapImageScaleRatio", "lightmapImageTransform" ), "\tcolor = frag_Color * image * lightmap;", GammaCorrect( "color" ), WriteFragment( "color" ) }; std::string source( JoinLines( sourceLines ) ); return source; }
static std::string GenVertexShader( shaderStage_t& stage, const std::string& texCoordName, std::vector< std::string >& attribs ) { size_t vertTransferOffset = 3; size_t vertAttrOffset = 2; uint32_t attribLocCounter = 0; // Vertex shader... // if we're not using core the last args for both the attribute and transfer // decl funcs won't be written; they'll likely just get optimized away std::vector< std::string > vertexSrc = { DeclAttributeVar( "position", "vec3", attribLocCounter++ ), texCoordName.empty() ? "" : DeclAttributeVar( texCoordName, "vec2", attribLocCounter++ ), DeclTransferVar( "frag_Tex", "vec2", "out" ), DeclCoreTransforms(), "void main(void) {", }; if ( stage.tcgen == TCGEN_ENVIRONMENT ) { vertexSrc.insert( vertexSrc.begin() + vertAttrOffset++, DeclAttributeVar( "normal", "vec3", attribLocCounter++ ) ); attribs.push_back( "normal" ); } vertexSrc.push_back( "\tgl_Position = viewToClip * modelToView * vec4( position, 1.0 );" ); if ( stage.tcgen == TCGEN_ENVIRONMENT ) { AddCalcEnvMap( vertexSrc, "position", "normal", "vec3( -modelToView[ 3 ] )" ); vertexSrc.push_back( "\tfrag_Tex = st;" ); } else { vertexSrc.push_back( "\tfrag_Tex = " + texCoordName + ";" ); } if ( UsesColor( stage ) ) { vertexSrc.insert( vertexSrc.begin() + vertAttrOffset++, DeclAttributeVar( "color", "vec4", attribLocCounter++ ) ); vertexSrc.insert( vertexSrc.begin() + vertTransferOffset++, DeclTransferVar( "frag_Color", "vec4", "out" ) ); vertexSrc.push_back( "\tfrag_Color = color;" ); attribs.push_back( "color" ); } return JoinLines( vertexSrc ); }
//! JoinLines function call will append //! the ending bracket for the main function, //! so we don't have to worry about it here. std::string GMakeMainVertexShader( void ) { std::vector< std::string > sourceLines = { DeclAttributeVar( "position", "vec3", 0 ), DeclAttributeVar( "tex0", "vec2", 1 ), DeclAttributeVar( "lightmap", "vec2", 2 ), DeclAttributeVar( "color", "vec4", 3 ), DeclTransferVar( "frag_Color", "vec4", "out" ), DeclTransferVar( "frag_Tex", "vec2", "out" ), DeclTransferVar( "frag_Lightmap", "vec2", "out" ), DeclCoreTransforms(), "void main(void) {", "\tgl_Position = viewToClip * modelToView * vec4( position, 1.0 );", "\tfrag_Color = color;", "\tfrag_Lightmap = lightmap;", "\tfrag_Tex = tex0;" }; std::string source( JoinLines( sourceLines ) ); return source; }
static std::string GenFragmentShader( shaderStage_t& stage, std::vector< std::string >& uniforms ) { size_t fragTransferOffset = 2; size_t fragUnifOffset = 3; // Fragment shader.... // Unspecified alphaGen implies a default 1.0 alpha channel std::vector< std::string > fragmentSrc = { DeclPrecision(), "const float gamma = 1.0 / 2.2;", DeclTransferVar( "frag_Tex", "vec2", "in" ), #ifdef G_USE_GL_CORE DeclTransferVar( "fragment", "vec4", "out" ), #endif "void main(void) {" }; // Add our base image data std::initializer_list<std::string> data = { "uniform sampler2D sampler0;", "uniform vec4 imageTransform;", "uniform vec2 imageScaleRatio;", "vec2 applyTransform(in vec2 coords) {", "\treturn coords * imageTransform.zw * imageScaleRatio + imageTransform.xy;", "}" }; fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, data ); fragmentSrc.push_back( "\tvec2 st = frag_Tex;" ); if ( UsesColor( stage ) ) { fragmentSrc.insert( fragmentSrc.begin() + fragTransferOffset++, DeclTransferVar( "frag_Color", "vec4", "in" ) ); } for ( const effect_t& op: stage.effects ) { // Modify the texture coordinate as necessary before we write to the texture if ( op.name == "tcModTurb" ) { fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, "uniform float tcModTurb;" ); fragmentSrc.push_back( "\tst *= tcModTurb;" ); uniforms.push_back( "tcModTurb" ); } else if ( op.name == "tcModScroll" ) { fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, "uniform vec4 tcModScroll;" ); fragmentSrc.push_back( "\tst += tcModScroll.xy * tcModScroll.zw;" ); uniforms.push_back( "tcModScroll" ); } else if ( op.name == "tcModRotate" ) { fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, "uniform mat2 texRotate;" ); fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, "uniform vec2 texCenter;" ); fragmentSrc.push_back( "\tst += texRotate * ( frag_Tex - texCenter );" ); uniforms.push_back( "texRotate" ); uniforms.push_back( "texCenter" ); } else if ( op.name == "tcModScale" ) { fragmentSrc.insert( fragmentSrc.begin() + fragUnifOffset, "uniform mat2 tcModScale;" ); fragmentSrc.push_back( "\tst = tcModScale * st;" ); uniforms.push_back( "tcModScale" ); } } switch ( stage.alphaFunc ) { case ALPHA_FUNC_UNDEFINED: WriteTexture( fragmentSrc, stage, nullptr ); break; case ALPHA_FUNC_GEQUAL_128: WriteTexture( fragmentSrc, stage, "color.a < 0.5" ); break; case ALPHA_FUNC_GTHAN_0: WriteTexture( fragmentSrc, stage, "color.a == 0" ); break; case ALPHA_FUNC_LTHAN_128: WriteTexture( fragmentSrc, stage, "color.a >= 0.5" ); break; } return JoinLines( fragmentSrc ); }
//@doc SECEdit //@mfunc Internal function. Cuts the text from pStartPos to pEndPos. Never deletes // pStartPos->pLine. //@rdesc int //@parm PTEXTPOS pStartPos //@parm PTEXTPOS pEndPos //@parm BOOL bSaveUndoRecord int SECEdit::Cut(PTEXTPOS pStartPos, PTEXTPOS pEndPos, BOOL bSaveUndoRecord) { int iRval; UNDORECORD UndoRecord; LPSTR lpText; PLINEDESC pFirstDeadLine,pNextDeadLine,pLastDeadLine; TEXTPOS TempPos; ASSERT(pStartPos); ASSERT(pEndPos); iRval = 0; if (m_bReadOnly) return IDS_OE_READONLY; if ((pStartPos->pLine == pEndPos->pLine) && (pStartPos->iOffset == pEndPos->iOffset)) return IDS_OE_NOSELECTION; if ((pStartPos->pLine == NULL) || (pEndPos->pLine == NULL)) return IDS_OE_NOSELECTION; // save the undo record if (bSaveUndoRecord) { UndoRecord.iRow = GetLineNo(pStartPos->pLine); if (pStartPos->pLine == pEndPos->pLine) UndoRecord.iEndRow = UndoRecord.iRow; else UndoRecord.iEndRow = GetLineNo(pEndPos->pLine); UndoRecord.iCol = pStartPos->iOffset; UndoRecord.iEndCol = pEndPos->iOffset; UndoRecord.iUndoType = OE_UNDO_CUT; lpText = Copy(pStartPos, pEndPos, FALSE); } if (pStartPos->pLine == pEndPos->pLine) { iRval = DeleteString(pStartPos, pEndPos->iOffset-pStartPos->iOffset, FALSE); } else { // lop the starting line off at iOffset if (pStartPos->iOffset < (pStartPos->pLine->iTxtSize-m_iLineEndLength)) { pStartPos->pLine->pText[pStartPos->iOffset] = 0; pStartPos->pLine->iTxtSize = pStartPos->iOffset; } // delete the marked part of the last line if (pEndPos->iOffset > pEndPos->pLine->iTxtSize) { pEndPos->iOffset = pEndPos->pLine->iTxtSize; /* (maybe) adjust for OE_CR/OE_LF */ char cFirst,cSecond; cFirst = pEndPos->pLine->pText[pEndPos->pLine->iTxtSize-m_iLineEndLength]; cSecond = m_szLineEnd[0]; if (cFirst == cSecond) { pEndPos->iOffset -= m_iLineEndLength; UndoRecord.iEndCol -= m_iLineEndLength; } } TempPos.pLine = pEndPos->pLine; TempPos.iOffset = 0; iRval = DeleteString(&TempPos, pEndPos->iOffset, FALSE); // link the two together, and unlink the ones in between if ((!iRval) || (iRval == IDS_OE_JOINLINE)) { if (pStartPos->pLine->pNext != pEndPos->pLine) { pFirstDeadLine = pStartPos->pLine->pNext; if (pEndPos->pLine) { pLastDeadLine = pEndPos->pLine->pPrev; pEndPos->pLine->pPrev = pStartPos->pLine; } else pLastDeadLine = NULL; pStartPos->pLine->pNext = pEndPos->pLine; if (pLastDeadLine) pLastDeadLine->pNext = NULL; while (pFirstDeadLine) { pNextDeadLine = pFirstDeadLine->pNext; FreeTextLine(pFirstDeadLine); pFirstDeadLine = pNextDeadLine; } } // join the chopped start with the chopped end iRval = JoinLines(pStartPos, FALSE); if (iRval == IDS_OE_EOF) iRval = 0; } } if (!iRval) { if (bSaveUndoRecord) { SaveUndoRecord(&UndoRecord,lpText); free(lpText); } // set the changed flag SetModified(TRUE); } return iRval; }