void CColorNewColorRampColorMapDialog::OnChangeColorMapRampEDITColorBlue()
{
UpdateData(true);
if (m_Blue<0) m_Blue=0;
if (m_Blue>1) m_Blue=1;
Quantity_Color aColor(m_Red,m_Green,m_Blue,Quantity_TOC_RGB);
m_ColorList.SetCurSel(aColor.Name());
UpdateData(false);
}
GrGLuint GLCpuPosInstancedArraysBench::setupShader(const GrGLContext* ctx) {
const GrGLSLCaps* glslCaps = ctx->caps()->glslCaps();
const char* version = glslCaps->versionDeclString();
// setup vertex shader
GrGLSLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
// setup fragment shader
GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps, &fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (glslCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
return CreateProgram(gl, vshaderTxt.c_str(), fshaderTxt.c_str());
}
//------------------------------------------------------------------------------
void IGUIFont_ft2::DrawString(IGUIInterfaceRender* pRender,
const CGUIStringRender& rString,
const CGUIVector2& rPos,
real fAlpha,
int32 nStartPos,
int32 nEndPos)
{
if( rString.m_strContent.empty())
{
//empty string
return;
}
CGUIVector2 aPos = rPos;
if( nEndPos<0 || nEndPos>int32(rString.m_strContent.size()))
{
nEndPos = rString.m_strContent.size();
}
const CGUIStringRenderInfo& rInfo = rString.m_aStringInfo;
CGUIFontData_ft2* pFontData = GetFontData( rInfo.m_uFontID );
for( int32 i=nStartPos; i<nEndPos; ++i)
{
SCharData_ft2 * pCharData = pFontData->GetCharData( rString.m_strContent[i] );
if( pCharData->m_pTexture)
{
CGUIRect aCharRect(
CGUIVector2(aPos.x+pCharData->m_fBearingX*rInfo.m_fFontScale, aPos.y-pCharData->m_fBearingY*rInfo.m_fFontScale),
CGUISize(pCharData->m_fBitmapWidth*rInfo.m_fFontScale,pCharData->m_fBitmapHeight*rInfo.m_fFontScale));
//dest area size
CGUIColor aColor(rInfo.m_aColor);
aColor.SetAlpha(aColor.GetAlpha()*fAlpha);
pRender->DrawTile(
aCharRect,
0,
pCharData->m_pTexture,
pCharData->m_aUV,
eImageOrientation_Normal,
aColor,
aColor,
aColor,
aColor);
}
aPos.x+=pCharData->m_aSize.m_fWidth*rInfo.m_fFontScale;
}
}
/////////////////////////////////////////////////////////////////////////////
// CColorNewColorRampColorMapDialog message handlers
BOOL CColorNewColorRampColorMapDialog::OnInitDialog()
{
CDialog::OnInitDialog();
for (int i = 0 ;i< 517 ; i++)
{
Standard_CString TheColorName = Quantity_Color::StringName((Quantity_NameOfColor)i);
// update the CComboBox to add the enumeration possibilities.
m_ColorList.AddString( TheColorName );
}
Quantity_Color aColor(m_Red,m_Green,m_Blue,Quantity_TOC_RGB);
m_ColorList.SetCurSel(aColor.Name());
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void zZone::ReadSync( nMessage & m )
{
// delegage
eNetGameObject::ReadSync( m );
if(shape && shape->isEmulatingOldZone())
{
// read color
rColor aColor(0.0, 0.7, 0.5);
if (!m.End())
{
m >> aColor.r_;
m >> aColor.g_;
m >> aColor.b_;
}
void CColorNewColorRampColorMapDialog::OnColorMapRampBUTTONEditColor()
{
UpdateData(true);
COLORREF m_clr ;
m_clr = RGB(m_Red*255,m_Green*255,m_Blue*255);
CColorDialog dlgColor(m_clr);
if (dlgColor.DoModal() == IDOK)
{
m_clr = dlgColor.GetColor();
m_Red = GetRValue(m_clr)/255.;
m_Green = GetGValue(m_clr)/255.;
m_Blue = GetBValue(m_clr)/255.;
}
Quantity_Color aColor(m_Red,m_Green,m_Blue,Quantity_TOC_RGB);
m_ColorList.SetCurSel(aColor.Name());
UpdateData(false);
}
void StGeometryTest::resizeBrightness() {
static const size_t BR_QUADS = 11;
static const size_t VERT_PER_QUAD = 6;
StGLContext& aCtx = getContext();
StGLVec2 rectSize(myCellSize.x(), 2.0f * myCellSize.y());
// move to the center
StGLVec2 bottomLeft(-1.0f + 0.5f * (2.0f - GLfloat(BR_QUADS) * rectSize.x()),
-1.0f + rectSize.y());
GLfloat anYBottom = bottomLeft.y() + 4.0f * myPixelSize.x();
GLfloat anYTop = bottomLeft.y() + rectSize.y() - 4.0f * myPixelSize.x();
// setup vertices
StArray<StGLVec4> aVertArray(BR_QUADS * VERT_PER_QUAD);
for(size_t quadId = 0; quadId < BR_QUADS; ++quadId) {
GLfloat anXLeft = bottomLeft.x() + GLfloat(quadId + 0) * rectSize.x() + 4.0f * myPixelSize.x();
GLfloat anXRight = bottomLeft.x() + GLfloat(quadId + 1) * rectSize.x() - 4.0f * myPixelSize.x();
aVertArray[quadId * VERT_PER_QUAD + 0] = StGLVec4(anXLeft, anYBottom, 0.0f, 1.0f);
aVertArray[quadId * VERT_PER_QUAD + 1] = StGLVec4(anXRight, anYBottom, 0.0f, 1.0f);
aVertArray[quadId * VERT_PER_QUAD + 2] = StGLVec4(anXRight, anYTop, 0.0f, 1.0f);
aVertArray[quadId * VERT_PER_QUAD + 3] = StGLVec4(anXRight, anYTop, 0.0f, 1.0f);
aVertArray[quadId * VERT_PER_QUAD + 4] = StGLVec4(anXLeft, anYBottom, 0.0f, 1.0f);
aVertArray[quadId * VERT_PER_QUAD + 5] = StGLVec4(anXLeft, anYTop, 0.0f, 1.0f);
}
myBrightness.changeVBO(ST_VBO_VERTEX)->init(aCtx, aVertArray);
// setup color (increased brightness): 3% 10% 20% 30% ... 100%
StArray<StGLVec4> aColorsArray(BR_QUADS * VERT_PER_QUAD);
StGLVec4 aColor(0.03f, 0.03f, 0.03f, 1.0f);
StGLVec4 aColorDelta(0.1f, 0.1f, 0.1f, 1.0f);
for(size_t quadId = 0; quadId < BR_QUADS; ++quadId) {
setValues(aColorsArray, aColor, quadId * VERT_PER_QUAD, VERT_PER_QUAD);
if(quadId == 0) {
aColor = aColorDelta;
} else {
aColor += aColorDelta;
}
}
myBrightness.changeVBO(ST_VBO_COLORS)->init(aCtx, aColorsArray);
}
//------------------------------------------------------------------------------
void IGUIFont_ft2::DrawString(IGUIInterfaceRender* pRender,
const CGUIStringRender& rString,
const CGUIRect& rStringRect,
ETextAlignmentHorz uTextAlignmentHorz,
ETextAlignmentVert uTextAlignmentVert,
real fAlpha,
int32 nStartPos,
int32 nEndPos)
{
if( rString.m_strContent.empty())
{
//empty string
return;
}
const CGUIStringRenderInfo& rInfo = rString.m_aStringInfo;
CGUIFontData_ft2* pFontData = GetFontData( rInfo.m_uFontID );
real fScaledStringWidth = GetStringWidth(rString);
real fScaledStringHeight = pFontData->GetFontSize() * rInfo.m_fFontScale;
CGUIVector2 aPos;
switch( uTextAlignmentHorz )
{
case eTextAlignment_Horz_Left:
aPos.x = rStringRect.m_fLeft;
break;
case eTextAlignment_Horz_Right:
aPos.x = rStringRect.m_fRight-fScaledStringWidth;
break;
case eTextAlignment_Horz_Center:
default:
aPos.x = floor(rStringRect.m_fLeft+(rStringRect.GetWidth()-fScaledStringWidth)/2);
break;
}
switch( uTextAlignmentVert )
{
case eTextAlignment_Vert_Up:
aPos.y = rStringRect.m_fTop;
break;
case eTextAlignment_Vert_Down:
aPos.y = rStringRect.m_fBottom - fScaledStringHeight;
break;
case eTextAlignment_Vert_Center:
default:
aPos.y = ceil(rStringRect.m_fTop + (rStringRect.GetHeight() - fScaledStringHeight) / 2);
break;
}
aPos.y += fScaledStringHeight;
if( nEndPos < 0 || nEndPos >int32( rString.m_strContent.size()))
{
nEndPos = rString.m_strContent.size();
}
for( int32 i= nStartPos; i<nEndPos; ++i)
{
SCharData_ft2 * pCharData = pFontData->GetCharData( rString.m_strContent[i] );
if( pCharData->m_pTexture)
{
CGUIRect aCharRect(
CGUIVector2(aPos.x+pCharData->m_fBearingX*rInfo.m_fFontScale, aPos.y-pCharData->m_fBearingY*rInfo.m_fFontScale),
CGUISize(pCharData->m_fBitmapWidth*rInfo.m_fFontScale,pCharData->m_fBitmapHeight*rInfo.m_fFontScale));
//dest area size
CGUIColor aColor(rInfo.m_aColor);
aColor.SetAlpha(aColor.GetAlpha()*fAlpha);
pRender->DrawTile(
aCharRect,
0,
pCharData->m_pTexture,
pCharData->m_aUV,
eImageOrientation_Normal,
aColor,
aColor,
aColor,
aColor);
}
aPos.x+=pCharData->m_aSize.m_fWidth*rInfo.m_fFontScale;
}
}
static GrGLuint compile_shader(const GrGLContext* ctx) {
const char* version = GrGLGetGLSLVersionDecl(*ctx);
// setup vertex shader
GrGLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
GrGLuint vertexShader = load_shader(gl, vshaderTxt.c_str(), GR_GL_VERTEX_SHADER);
// setup fragment shader
GrGLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLAppendGLSLDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, gl->fStandard,
&fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (ctx->caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
GrGLuint fragmentShader = load_shader(gl, fshaderTxt.c_str(), GR_GL_FRAGMENT_SHADER);
GrGLint shaderProgram;
GR_GL_CALL_RET(gl, shaderProgram, CreateProgram());
GR_GL_CALL(gl, AttachShader(shaderProgram, vertexShader));
GR_GL_CALL(gl, AttachShader(shaderProgram, fragmentShader));
GR_GL_CALL(gl, LinkProgram(shaderProgram));
// Check for linking errors
GrGLint success;
GrGLchar infoLog[512];
GR_GL_CALL(gl, GetProgramiv(shaderProgram, GR_GL_LINK_STATUS, &success));
if (!success) {
GR_GL_CALL(gl, GetProgramInfoLog(shaderProgram, 512, NULL, infoLog));
SkDebugf("Linker Error: %s\n", infoLog);
}
GR_GL_CALL(gl, DeleteShader(vertexShader));
GR_GL_CALL(gl, DeleteShader(fragmentShader));
return shaderProgram;
}
GrGLuint GLVec4ScalarBench::setupShader(const GrGLContext* ctx) {
const GrShaderCaps* shaderCaps = ctx->caps()->shaderCaps();
const char* version = shaderCaps->versionDeclString();
// this shader draws fNumStages overlapping circles of increasing opacity (coverage) and
// decreasing size, with the center of each subsequent circle closer to the bottom-right
// corner of the screen than the previous circle.
// set up vertex shader; this is a trivial vertex shader that passes through position and color
GrShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
GrShaderVar oPosition("o_position", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier);
GrShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kIn_TypeModifier);
GrShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
" o_position = a_position;\n"
" o_color = a_color;\n"
"}\n");
// set up fragment shader; this fragment shader will have fNumStages coverage stages plus an
// XP stage at the end. Each coverage stage computes the pixel's distance from some hard-
// coded center and compare that to some hard-coded circle radius to compute a coverage.
// Then, this coverage is mixed with the coverage from the previous stage and passed to the
// next stage.
GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
oPosition.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oPosition.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
oColor.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (shaderCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "sk_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
" vec4 outputColor;\n"
" %s outputCoverage;\n"
" outputColor = vec4(%s, 1.0);\n"
" outputCoverage = %s;\n",
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4" : "float",
oColor.getName().c_str(),
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(1.0)" : "1.0"
);
float radius = 1.0f;
for (uint32_t i = 0; i < fNumStages; i++) {
float centerX = 1.0f - radius;
float centerY = 1.0f - radius;
fshaderTxt.appendf(
" {\n"
" float d = length(%s - vec2(%f, %f));\n"
" float edgeAlpha = clamp(100.0 * (%f - d), 0.0, 1.0);\n"
" outputCoverage = 0.5 * outputCoverage + 0.5 * %s;\n"
" }\n",
oPosition.getName().c_str(), centerX, centerY,
radius,
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(edgeAlpha)" : "edgeAlpha"
);
radius *= 0.8f;
}
fshaderTxt.appendf(
" {\n"
" %s = outputColor * outputCoverage;\n"
" }\n"
"}\n",
fsOutName);
return CreateProgram(ctx, vshaderTxt.c_str(), fshaderTxt.c_str());
}
