// Test that flipping the Y component works correctly
TEST_P(CopyTextureTest, FlipY)
{
if (!checkExtensions())
{
return;
}
GLColor rgbaPixels[4] = {GLColor(255u, 255u, 255u, 255u), GLColor(127u, 127u, 127u, 127u),
GLColor(63u, 63u, 63u, 127u), GLColor(255u, 255u, 255u, 0u)};
glBindTexture(GL_TEXTURE_2D, mTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
glCopyTextureCHROMIUM(mTextures[0], mTextures[1], GL_RGBA, GL_UNSIGNED_BYTE, GL_TRUE, GL_FALSE,
GL_FALSE);
EXPECT_GL_NO_ERROR();
// Check that FB is complete.
EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
EXPECT_PIXEL_COLOR_EQ(0, 0, rgbaPixels[2]);
EXPECT_PIXEL_COLOR_EQ(1, 0, rgbaPixels[3]);
EXPECT_PIXEL_COLOR_EQ(0, 1, rgbaPixels[0]);
EXPECT_PIXEL_COLOR_EQ(1, 1, rgbaPixels[1]);
EXPECT_GL_NO_ERROR();
}
namespace angle
{
const GLColor GLColor::red = GLColor(255u, 0u, 0u, 255u);
const GLColor GLColor::green = GLColor(0u, 255u, 0u, 255u);
const GLColor GLColor::blue = GLColor(0u, 0u, 255u, 255u);
const GLColor GLColor::cyan = GLColor(0u, 255u, 255u, 255u);
const GLColor GLColor::black = GLColor(0u, 0u, 0u, 255u);
namespace
{
float ColorNorm(GLubyte channelValue)
{
return static_cast<float>(channelValue) / 255.0f;
}
} // anonymous namespace
GLColor::GLColor() : R(0), G(0), B(0), A(0)
{
}
GLColor::GLColor(GLubyte r, GLubyte g, GLubyte b, GLubyte a) : R(r), G(g), B(b), A(a)
{
}
GLColor::GLColor(GLuint colorValue) : R(0), G(0), B(0), A(0)
{
memcpy(&R, &colorValue, sizeof(GLuint));
}
Vector4 GLColor::toNormalizedVector() const
{
return Vector4(ColorNorm(R), ColorNorm(G), ColorNorm(B), ColorNorm(A));
}
GLColor ReadColor(GLint x, GLint y)
{
GLColor actual;
glReadPixels((x), (y), 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &actual.R);
EXPECT_GL_NO_ERROR();
return actual;
}
bool operator==(const GLColor &a, const GLColor &b)
{
return a.R == b.R && a.G == b.G && a.B == b.B && a.A == b.A;
}
std::ostream &operator<<(std::ostream &ostream, const GLColor &color)
{
ostream << "(" << static_cast<unsigned int>(color.R) << ", "
<< static_cast<unsigned int>(color.G) << ", " << static_cast<unsigned int>(color.B)
<< ", " << static_cast<unsigned int>(color.A) << ")";
return ostream;
}
} // namespace angle
void InstrumentRenderer::resetColors() {
auto sharedWorkspace = m_actor.getWorkspace();
const double vmin(m_actor.minValue()), vmax(m_actor.maxValue());
// Reset all colors to 0 and resize m_colors to the appropriate size
const auto zero = m_colorMap.rgb(vmin, vmax, 0);
const auto &compInfo = m_actor.componentInfo();
m_colors.assign(compInfo.size(),
GLColor(qRed(zero), qGreen(zero), qBlue(zero), 1));
// No data/masked colors
static const auto invalidColor = GLColor(80, 80, 80, 1);
static const auto maskedColor = GLColor(100, 100, 100, 1);
// Compute required colors for the detectors in a single shot to avoid
// repeated calls to python and back in the matplotlib-based implementation
const auto &detInfo = m_actor.detectorInfo();
std::vector<double> counts(detInfo.size());
for (size_t det = 0; det < detInfo.size(); ++det) {
counts[det] = m_actor.getIntegratedCounts(det);
}
auto rgba = m_colorMap.rgb(vmin, vmax, counts);
// Now apply colors taking into account detectors with bad counts and detector
// masking
Mantid::API::IMaskWorkspace_sptr maskWS = m_actor.getMaskWorkspaceIfExists();
const auto &detectorIDs = detInfo.detectorIDs();
// Defines a mask checker lambda dependent on if we have a mask workspace or
// not. Done once outside the loop to avoid repeated if branches in the loop
std::function<bool(size_t)> isMasked;
if (maskWS) {
isMasked = [&detInfo, &detectorIDs, &maskWS](size_t index) {
return maskWS->isMasked(detectorIDs[index]) || detInfo.isMasked(index);
};
} else {
isMasked = [&detInfo](size_t index) { return detInfo.isMasked(index); };
}
for (size_t det = 0; det < counts.size(); ++det) {
if (!isMasked(det)) {
const double integratedValue(counts[det]);
if (integratedValue > -1) {
const auto &color = rgba[det];
m_colors[det] =
GLColor(qRed(color), qGreen(color), qBlue(color),
static_cast<int>(255 * (integratedValue / vmax)));
} else
m_colors[det] = invalidColor;
} else {
m_colors[det] = maskedColor;
}
}
// finish off rest of the components with the mask color
for (const auto comp : m_actor.components())
m_colors[comp] = maskedColor;
}
void GLLight::SetParams( GLfloat* ambient, GLfloat* diffuse, GLfloat* specular, GLfloat* position )
{
ambient_ = GLColor ( ambient [ 0 ], ambient [ 1 ], ambient [ 2 ], ambient [ 3 ] );
diffuse_ = GLColor ( diffuse [ 0 ], diffuse [ 1 ], diffuse [ 2 ], diffuse [ 3 ] );
specular_ = GLColor ( specular[ 0 ], specular[ 1 ], specular[ 2 ], specular[ 3 ] );
position_ = GLPosition( position[ 0 ], position[ 1 ], position[ 2 ], position[ 3 ] );
glLightfv( lightNum_, GL_AMBIENT , ambient_ .pointer() );
glLightfv( lightNum_, GL_DIFFUSE , diffuse_ .pointer() );
glLightfv( lightNum_, GL_SPECULAR, specular_.pointer() );
glLightfv( lightNum_, GL_POSITION, position_.pointer() );
}
ListMenuStyle::ListMenuStyle() :
_background(GLColor(0xFF000000)),
_shadow(GLColor(0xF7FFFFFF)),
_header_text(0xFF9FFFFF),
_paint_first_line(false),
_paint_last_line(false),
_list_r(0, 0, 230, 300),
_size(10, 60, 230, 300)
{
}
GLColor InstrumentRenderer::makePickColor(size_t pickID) {
pickID += 1;
unsigned char r, g, b;
r = static_cast<unsigned char>(pickID / 65536);
g = static_cast<unsigned char>((pickID % 65536) / 256);
b = static_cast<unsigned char>((pickID % 65536) % 256);
return GLColor(r, g, b);
}
void skelpath::draw3dNurbs(){
//draw 3d nurbs using member variable"disNurbsss3d"
if( disNurbsss3d.size() > 0){
for( int i=0; i<disNurbsss3d[0].size(); ++i )
if( i != activeTmpId )
GlobalFun::draw3dCurves(std::vector<Curve3D>(1,disNurbsss3d[0][i]) , GLColor( 0.8,0, 0, 1), true, false, ReconstructorPara::nurbsDisplaySize ) ;
}
}
Explosion::Explosion(void)
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
if(Random::RandomChance(0.2f))
{
fill_.SetFillColor(GLColor(255, 255, 0));
}
else
{
fill_.SetFillColor(GLColor(255, static_cast<unsigned char>(Random::RandomQuantity(20,120)), static_cast<unsigned char>(Random::RandomQuantity(0,20))));
}
lifetime_ = ExplosionLifetime;
ltv_transform_ = Matrix4f::createScale(0);
}
GLVector * GLVector::fromXml(const QDomElement &object)
{
if (object.isNull() || object.attribute("type","") != "vector")
return NULL;
QString id = object.attribute("id","");
GLdouble sx = 0.0;
GLdouble sy = 0.0;
GLdouble sz = 0.0;
GLdouble ex = 0.0;
GLdouble ey = 0.0;
GLdouble ez = 0.0;
QDomNodeList points = object.elementsByTagName("point");
if (points.count() == 2)
{
QDomElement point = points.at(0).toElement();
sx = point.attribute("x","0").toDouble();
sy = point.attribute("y","0").toDouble();
sz = point.attribute("z","0").toDouble();
point = points.at(1).toElement();
ex = point.attribute("x","0").toDouble();
ey = point.attribute("y","0").toDouble();
ez = point.attribute("z","0").toDouble();
}
uchar r=0,g=0,b=0,a=255;
QDomNodeList colors = object.elementsByTagName("color");
if (!colors.isEmpty())
{
QDomElement colorNode = colors.at(0).toElement();
r = (uchar)colorNode.attribute("r","0").toUShort(NULL, 16);
g = (uchar)colorNode.attribute("g","0").toUShort(NULL, 16);
b = (uchar)colorNode.attribute("b","0").toUShort(NULL, 16);
a = (uchar)colorNode.attribute("a","ff").toUShort(NULL, 16);
}
int time = 0;
QDomNodeList times = object.elementsByTagName("time");
if (!times.isEmpty())
{
QDomElement timeNode = times.at(0).toElement();
time = timeNode.text().toInt();
}
return new GLVector(sx,sy,sz,ex,ey,ez,GLColor(r,g,b,a),id,time);
}
BeamCharge::BeamCharge(void)
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
fill_.SetFillColor(GLColor(255, 255, 255));
lifetime_ = 1;
ltv_transform_ = Matrix4f::createScale(0);
angle_ = Random::RandomRange(0,360);
}
Sparks::Sparks(void)
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
fill_.SetFillColor(GLColor(255, static_cast<unsigned char>(Random::RandomRange(200,255)), static_cast<unsigned char>(Random::RandomRange(200,255))));
lifetime_ = SPARKS_LIFETIME;
ltv_transform_ = Matrix4f::createScale(0);
}
void LabelDecoration::Tick(float _timespan, Matrix4f _transform, std::vector<Decoration_ptr>& _decoration_spawn)
{
if(source_!=NULL)
{
source_location_ = source_->GetGlobalPosition();
}
else
{
if(lifetime_ > 1.0f)
lifetime_ = 1.0f;
}
float alpha = 0;
if(full_lifetime_ - lifetime_ < 0.1f)
{
alpha = (full_lifetime_ - lifetime_) / 0.1f;
}else if(lifetime_ < 1.0f && lifetime_ > 0.0f)
{
alpha = lifetime_;
} else if(lifetime_ < 0.0f)
{
alpha = 0.0f;
} else
{
alpha = 1.0f;
}
fill_.SetFillColor(GLColor(255, 255, 255, alpha));
SetPosition(Camera::Instance().ScreenToWorld(screen_position_));
Decoration::Tick(_timespan, _transform, _decoration_spawn);
for(std::vector<Billboard*>::iterator it = labels_.begin(); it != labels_.end(); ++it)
{
(*it)->SetColor(GLColor(255, 255, 255, alpha));
}
}
PhotonPulse::PhotonPulse(Vector3f _position)
:Projectile()
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
fill_.SetFillColor(GLColor(150, 159, 255));
damage_ = 45;
lifetime_ = 3.0;
velocity_.y = 750;
position_ = _position;
mass_ = 0;
}
PlasmaRound::PlasmaRound(Vector3f _position)
:Projectile()
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
fill_.SetFillColor(GLColor(255, 255, 255));
damage_ = 45.0;
lifetime_ = 4.0;
velocity_.y = 450;
position_ = _position;
mass_ = 25;
}
GLPoint * GLPoint::fromXml(const QDomElement &object)
{
if (object.isNull() || object.attribute("type","") != "point")
return NULL;
QString id = object.attribute("id","");
GLdouble x = 0.0;
GLdouble y = 0.0;
GLdouble z = 0.0;
QDomNodeList points = object.elementsByTagName("point");
if (!points.isEmpty())
{
QDomElement point = points.at(0).toElement();
x = point.attribute("x","0").toDouble();
y = point.attribute("y","0").toDouble();
z = point.attribute("z","0").toDouble();
}
uchar r=0,g=0,b=0,a=255;
QDomNodeList colors = object.elementsByTagName("color");
if (!colors.isEmpty())
{
QDomElement colorNode = colors.at(0).toElement();
r = (uchar)colorNode.attribute("r","0").toUShort(NULL, 16);
g = (uchar)colorNode.attribute("g","0").toUShort(NULL, 16);
b = (uchar)colorNode.attribute("b","0").toUShort(NULL, 16);
a = (uchar)colorNode.attribute("a","ff").toUShort(NULL, 16);
}
int time = 0;
QDomNodeList times = object.elementsByTagName("time");
if (!times.isEmpty())
{
QDomElement timeNode = times.at(0).toElement();
time = timeNode.text().toInt();
}
return new GLPoint(x,y,z, GLColor(r,g,b,a), id, time);
}
SwarmMissile::SwarmMissile(Vector3f _position, BaseEntity* _target)
: HomingProjectile(_target)
{
if(!initialised_)
{
InitialiseGraphics();
initialised_ = true;
}
fill_.GetFillVerts() = Datastore::Instance().GetVerts(fill_verts_index_);
fill_.SetDisplayList(fill_dl_);
fill_.SetFillColor(GLColor(255,255,0));
fill_.GetFillColor().a = 127;
lifetime_ = 5;
damage_ = 70;
turn_rate_ = 150;
scalar_speed_ = 200;
velocity_.y = scalar_speed_;
position_ = _position;
mass_ = 25;
}
void FusionForeverWidget::DrawSection(Section_ptr section, std::string name, std::vector<std::pair<std::string, QPixmap*> >& icons)
{
if(section)
{
float radius = section->GetRadius();
Camera::Instance().SetSmallestDimension(40);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Camera::Instance().SetupCamera();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//Draw Section
section->DeathTick();
section->SetOutlineColor(GLColor(0,0,0));
section->DrawSelf();
glFlush();
QImage icon = grabFrameBuffer();
if(height() > width())
{
int top = (height() - width()) / 2;
QImage icon2 = icon.copy(0, top, width(), width());
QPixmap pm = QPixmap::fromImage(icon2);
icons.push_back(std::pair<std::string, QPixmap*>(name, new QPixmap(pm.pixmapData())));
} else
{
int left = (width() - height()) / 2;
QImage icon2 = icon.copy(left, 0, height(), height());
QPixmap pm = QPixmap::fromImage(icon2);
icons.push_back(std::pair<std::string, QPixmap*>(name, new QPixmap(pm.pixmapData())));
}
delete section;
}
}
void StandardInputProcessor::Hover(int mx,int my)
{
if(move) changed = true;
useSpaceball = false;
move = false;
Ray3D ray;
GetClickRay(mx, my, ray);
int link;
Vector3 localPos;
RobotInfo* rob = world->ClickRobot( ray, link, localPos);
Robot* robot = GetRobot();
if (rob) {
currentLink = link;
currentPoint = localPos;
currentDestination = robot->links[currentLink].T_World*localPos;
rob->view.SetGrey();
rob->view.SetColor(currentLink,GLColor(1, 1, 0));
} else {
world->robots[0].view.SetGrey();
currentLink = -1;
}
}
wxImage ColorInfoData::UIImage(const ColorType type, const wxSize &size)
{
wxASSERT((0 <= type) && (CR_SIZE > type));
checkColors();
//now fill it with the color requested
wxColour color = UIColor(type);
wxColour border = GLColor(type);
// Create a transparent border so it's not just a blob of color.
wxColour transparent = SKIN.Element(shIconTransparent);
// The easiest way to do this is to just create a memory bitmap and draw
// into it.
wxBitmap bitmap(size.x, size.y);
wxMemoryDC dc;
dc.SelectObject(bitmap);
// Transparent outline.
dc.SetBrush(wxBrush(transparent));
dc.SetPen(wxPen(transparent));
dc.DrawRectangle(0, 0, size.x, size.y);
// Border.
dc.SetBrush(wxBrush(border));
dc.SetPen(wxPen(border));
dc.DrawRectangle(1, 1, size.x - 2, size.y - 2);
// Color.
dc.SetBrush(wxBrush(color));
dc.SetPen(wxPen(color));
dc.DrawRectangle(2, 2, size.x - 4, size.y - 4);
dc.SelectObject(wxNullBitmap);
return bitmap.ConvertToImage();
}
void GLLight::SetSpecular( float r, float g, float b, float a )
{
specular_ = GLColor( r, g, b, a );
glLightfv( lightNum_, GL_SPECULAR, specular_.pointer() );
}
Outlined::Outlined(void)
{
outline_color_ = GLColor(255,255,255);
outline_display_list_ = -1;
}
namespace angle
{
const GLColorRGB GLColorRGB::black(0u, 0u, 0u);
const GLColorRGB GLColorRGB::blue(0u, 0u, 255u);
const GLColorRGB GLColorRGB::green(0u, 255u, 0u);
const GLColorRGB GLColorRGB::red(255u, 0u, 0u);
const GLColorRGB GLColorRGB::yellow(255u, 255u, 0);
const GLColor GLColor::black = GLColor(0u, 0u, 0u, 255u);
const GLColor GLColor::blue = GLColor(0u, 0u, 255u, 255u);
const GLColor GLColor::cyan = GLColor(0u, 255u, 255u, 255u);
const GLColor GLColor::green = GLColor(0u, 255u, 0u, 255u);
const GLColor GLColor::red = GLColor(255u, 0u, 0u, 255u);
const GLColor GLColor::yellow = GLColor(255u, 255u, 0, 255u);
const GLColor GLColor::white = GLColor(255u, 255u, 255u, 255u);
const GLColor16 GLColor16::white = GLColor16(65535u, 65535u, 65535u, 65535u);
namespace
{
float ColorNorm(GLubyte channelValue)
{
return static_cast<float>(channelValue) / 255.0f;
}
GLubyte ColorDenorm(float colorValue)
{
return static_cast<GLubyte>(colorValue * 255.0f);
}
// Use a custom ANGLE platform class to capture and report internal errors.
class TestPlatform : public angle::Platform
{
public:
TestPlatform() : mIgnoreMessages(false) {}
void logError(const char *errorMessage) override;
void logWarning(const char *warningMessage) override;
void logInfo(const char *infoMessage) override;
void ignoreMessages();
void enableMessages();
private:
bool mIgnoreMessages;
};
void TestPlatform::logError(const char *errorMessage)
{
if (mIgnoreMessages)
return;
FAIL() << errorMessage;
}
void TestPlatform::logWarning(const char *warningMessage)
{
if (mIgnoreMessages)
return;
std::cerr << "Warning: " << warningMessage << std::endl;
}
void TestPlatform::logInfo(const char *infoMessage)
{
if (mIgnoreMessages)
return;
angle::WriteDebugMessage("%s\n", infoMessage);
}
void TestPlatform::ignoreMessages()
{
mIgnoreMessages = true;
}
void TestPlatform::enableMessages()
{
mIgnoreMessages = false;
}
TestPlatform g_testPlatformInstance;
std::array<Vector3, 4> GetIndexedQuadVertices()
{
std::array<Vector3, 4> vertices;
vertices[0] = Vector3(-1.0f, 1.0f, 0.5f);
vertices[1] = Vector3(-1.0f, -1.0f, 0.5f);
vertices[2] = Vector3(1.0f, -1.0f, 0.5f);
vertices[3] = Vector3(1.0f, 1.0f, 0.5f);
return vertices;
}
} // anonymous namespace
GLColorRGB::GLColorRGB() : R(0), G(0), B(0)
{
}
GLColorRGB::GLColorRGB(GLubyte r, GLubyte g, GLubyte b) : R(r), G(g), B(b)
{
}
GLColorRGB::GLColorRGB(const Vector3 &floatColor)
: R(ColorDenorm(floatColor.x)), G(ColorDenorm(floatColor.y)), B(ColorDenorm(floatColor.z))
{
}
GLColor::GLColor() : R(0), G(0), B(0), A(0)
{
}
GLColor::GLColor(GLubyte r, GLubyte g, GLubyte b, GLubyte a) : R(r), G(g), B(b), A(a)
{
}
GLColor::GLColor(const Vector4 &floatColor)
: R(ColorDenorm(floatColor.x)),
G(ColorDenorm(floatColor.y)),
B(ColorDenorm(floatColor.z)),
A(ColorDenorm(floatColor.w))
{
}
GLColor::GLColor(const GLColor16 &color16)
: R(static_cast<GLubyte>(color16.R)),
G(static_cast<GLubyte>(color16.G)),
B(static_cast<GLubyte>(color16.B)),
A(static_cast<GLubyte>(color16.A))
{
}
GLColor::GLColor(GLuint colorValue) : R(0), G(0), B(0), A(0)
{
memcpy(&R, &colorValue, sizeof(GLuint));
}
Vector4 GLColor::toNormalizedVector() const
{
return Vector4(ColorNorm(R), ColorNorm(G), ColorNorm(B), ColorNorm(A));
}
GLColor ReadColor(GLint x, GLint y)
{
GLColor actual;
glReadPixels((x), (y), 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &actual.R);
EXPECT_GL_NO_ERROR();
return actual;
}
bool operator==(const GLColor &a, const GLColor &b)
{
return a.R == b.R && a.G == b.G && a.B == b.B && a.A == b.A;
}
std::ostream &operator<<(std::ostream &ostream, const GLColor &color)
{
ostream << "(" << static_cast<unsigned int>(color.R) << ", "
<< static_cast<unsigned int>(color.G) << ", " << static_cast<unsigned int>(color.B)
<< ", " << static_cast<unsigned int>(color.A) << ")";
return ostream;
}
GLColor16::GLColor16() : R(0), G(0), B(0), A(0)
{
}
GLColor16::GLColor16(GLushort r, GLushort g, GLushort b, GLushort a) : R(r), G(g), B(b), A(a)
{
}
GLColor16 ReadColor16(GLint x, GLint y)
{
GLColor16 actual;
glReadPixels((x), (y), 1, 1, GL_RGBA, GL_UNSIGNED_SHORT, &actual.R);
EXPECT_GL_NO_ERROR();
return actual;
}
bool operator==(const GLColor16 &a, const GLColor16 &b)
{
return a.R == b.R && a.G == b.G && a.B == b.B && a.A == b.A;
}
std::ostream &operator<<(std::ostream &ostream, const GLColor16 &color)
{
ostream << "(" << static_cast<unsigned int>(color.R) << ", "
<< static_cast<unsigned int>(color.G) << ", " << static_cast<unsigned int>(color.B)
<< ", " << static_cast<unsigned int>(color.A) << ")";
return ostream;
}
} // namespace angle
ListMenuItemStyle::ListMenuItemStyle() :
m_separator(0xFF332828),
m_lineLongSelected(GLColor(0x4FFF00FF)),
m_listText(0xFFFFFFFF),
m_pressedText(0xFFFFFFFF),
m_longPressedText(0xFFFFFFFF),
m_inactiveText(0xffa3a3a3),
m_inactivePressedText(0xffa3a3a3),
m_inactiveLongPresedText(0xffa3a3a3),
m_fontSize(24)
{
m_lineSelected = Brush( [](Brush &, const Rect & rect) {
unsigned short alpha = 0x30;
for(int i=1; i<rect.h()/2; ++i, alpha += 4) {
if(alpha >= 0xff) {
alpha = 0xff;
}
GLColor c = ((unsigned char)alpha << 24) | 0x0000FF;
glSetPen(c);
glDrawHLine(rect.x(), rect.x2()-1, rect.y()+i);
}
for(int i=(const int)rect.h()/2; i<rect.h()-1; ++i, alpha -= 4) {
if(alpha <= 0x20) {
alpha = 0x20;
}
GLColor c = ((unsigned char)alpha << 24) | 0x0000FF;
glSetPen(c);
glDrawHLine(rect.x(), rect.x2()-1, rect.y()+i);
}
});
// Set the separator as gradient-line
m_separator = Brush( [](Brush &, const Rect & rect) {
/*const short alpha = 0xff;
float colors = 255.0f;
float r = rect.w() / 2;
float sub_f = 255 / r + (r * 0.1f/100.0f);
for(int i=r; i > 0; --i)
{
GLColor col = colors;
GLColor c = ((unsigned char)alpha << 24) | (col << 16) | (col << 8) | (col & 0xff);
glActiveContext()->setColorPixel(glActiveContext(), rect.x()+i, rect.y(), c);
colors -= sub_f;
if(colors < 0)
colors = 0;
}
colors = 0xff;
for(int i=0; i < r; ++i)
{
GLColor col = colors;
GLColor c = ((unsigned char)alpha << 24) | (col << 16) | (col << 8) | (col & 0xff);
glActiveContext()->setColorPixel(glActiveContext(), rect.x()+r+i, rect.y(), c);
colors -= sub_f;
if(colors < 0)
colors = 0;
}*/
glSetPen(0x4FFFFFFF);
glDrawHLine(rect.x()+4, rect.x2()-4, rect.y());
});
}
void CFont::SetColor(float iRed, float iGreen, float iBlue) {
// Set color
mColor = GLColor(iRed, iGreen, iBlue, 1.0);
}
void GLLight::SetAmbient( float r, float g, float b, float a )
{
ambient_ = GLColor( r, g, b, a );
glLightfv( lightNum_, GL_AMBIENT, ambient_.pointer() );
}
LabelDecoration::LabelDecoration(BaseEntity* _source, Vector3f _screen_position, float _lifetime)
{
source_ = _source;
assert(source_ != NULL);
source_->AddSubscriber(this);
source_location_ = source_->GetGlobalPosition();
lifetime_ = _lifetime;
full_lifetime_ = _lifetime;
fill_.SetFillColor(GLColor(255, 255, 255));
Section_ptr section = (Section_ptr)_source;
Vector3f screen_position = _screen_position;
Vector3f icon_spacing(25, 0, 0);
if(screen_position.x > Camera::Instance().GetWidth() * 0.1f)
icon_spacing.x *= -1;
bool interesting = false;
std::vector<std::string> tags = GetRelevantTags((Section*)_source);
for(std::vector<std::string>::iterator it = tags.begin(); it != tags.end(); ++it)
{
if(!it->compare("Weapon"))
{
Billboard* bb = new Billboard("WeaponIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Beam"))
{
Billboard* bb = new Billboard("BeamIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Shield"))
{
Billboard* bb = new Billboard("ShieldIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Generator"))
{
Billboard* bb = new Billboard("GeneratorIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("EnergyStorage"))
{
Billboard* bb = new Billboard("EnergyStorageIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Thruster"))
{
Billboard* bb = new Billboard("ThrusterIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Core"))
{
Billboard* bb = new Billboard("CoreIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
if(!it->compare("Joint"))
{
Billboard* bb = new Billboard("JointIcon", BillboardType::ScreenSpace);
bb->SetPosition(screen_position);
labels_.push_back(bb);
screen_position += icon_spacing;
interesting = true;
}
}
if(!interesting)
lifetime_ = -1;
screen_position_ = screen_position;
}
void GLLight::SetDiffuse( float r, float g, float b, float a )
{
diffuse_ = GLColor( r, g, b, a );
glLightfv( lightNum_, GL_DIFFUSE, diffuse_.pointer() );
}
