//------------------------------------------------------------------------------
// determineColors() - take our value, and look for a corresponding color
// and breakpoint
//------------------------------------------------------------------------------
bool ColorRotary::determineColor(const LCreal value)
{
bool ok = false;
int breakPoint = 0;
// find out where we are in the break table
unsigned int i = 0;
// do an endpoint check while we are at it
if (value >= myValues[numVals-1]) breakPoint = numVals;
while (!ok && i < numVals) {
if (value >= myValues[i] && value < myValues[i+1]){
breakPoint = (i + 1);
ok = true;
}
else i++;
}
// now set the proper color (using the breakpoint index)
if (myColors != nullptr) {
Basic::Pair* pair = myColors->getPosition(breakPoint);
if (pair != nullptr) {
Basic::Color* listcolor = dynamic_cast<Basic::Color*>(pair->object());
if (listcolor != nullptr) {
const osg::Vec4* vec = static_cast<const osg::Vec4*>(listcolor->getRGBA());
color = *vec;
ok = true;
}
}
}
return ok;
}
//------------------------------------------------------------------------------
// drawFunc()
//------------------------------------------------------------------------------
void Polygon::drawFunc()
{
BEGIN_DLIST
unsigned int nv = getNumberOfVertices();
const osg::Vec3* vertices = getVertices();
if (nv >= 2) {
// Draw with texture
unsigned int ntc = getNumberOfTextureCoords();
if (ntc > 0 && hasTexture()) {
const osg::Vec2* texCoord = getTextureCoord();
unsigned int tc = 0; // texture count
glBegin(GL_POLYGON);
for (unsigned int i = 0; i < nv; i++) {
if (tc < ntc) {
lcTexCoord2v(texCoord[tc++].ptr());
}
lcVertex3v( vertices[i].ptr() );
}
glEnd();
}
// Draw without texture
else {
// get our color gradient, because if we have one, instead of a regular color, we will
// override it here and set it on a per vertex level.
ColorGradient* colGradient = dynamic_cast<ColorGradient*>(getColor());
glBegin(GL_POLYGON);
osg::Vec3* ptr = nullptr;
for (unsigned int i = 0; i < nv; i++) {
if (colGradient != nullptr) {
Basic::Color* col = colGradient->getColorByIdx(i+1);
if (col != nullptr)
glColor4f(static_cast<GLfloat>(col->red()), static_cast<GLfloat>(col->green()),
static_cast<GLfloat>(col->blue()), static_cast<GLfloat>(col->alpha()));
}
// if we have a material name, we will set up like we have a material
if (getMaterialName() != nullptr) {
//lcVertex3v( vertices[i].ptr() );
ptr = const_cast<osg::Vec3*>(reinterpret_cast<const osg::Vec3*>(vertices[i].ptr()));
if (ptr != nullptr) {
calcNormal();
lcNormal3(norm.x(), norm.y(), -(norm.z()));
lcVertex3(ptr->x(), ptr->y(), ptr->z());
}
}
else {
lcVertex3v(vertices[i].ptr());
}
}
glEnd();
}
}
END_DLIST
}
//------------------------------------------------------------------------------
// updateData() -- update non time-critical threads here
//------------------------------------------------------------------------------
void GhostHorizon::updateData(const LCreal dt)
{
// Update our base class
BaseClass::updateData(dt);
// get our table to determine our min and max value
LCreal maxPitch = 90;
LCreal minPitch = -90;
const Basic::Table1* table = getScalingTable();
if (table != nullptr) {
maxPitch = table->getMaxX();
minPitch = table->getMinX();
}
LCreal value = getPreScaleInstValue();
if (value <= minPitch/* || value >= pitchLim*/) {
setVisibility(true);
// scale our location value
//location = -(location - margin);
if (sColorName != nullptr) {
BasicGL::Display* d = getDisplay();
if (d != nullptr) {
Basic::Color* c = d->getColor(sColorName->getString());
if (c != nullptr) {
skyColor.set(c->red(), c->green(), c->blue());
}
}
}
}
else if (value >= maxPitch) {
setVisibility(true);
//location = -(location + margin);
if (gColorName != nullptr) {
BasicGL::Display* d = getDisplay();
if (d != nullptr) {
Basic::Color* c = d->getColor(gColorName->getString());
if (c != nullptr) {
groundColor.set(c->red(), c->green(), c->blue());
}
}
}
}
else setVisibility(false);
}
// Draw function
void Quad::drawFunc()
{
bool ok = false;
// Draw with texture
const unsigned int nv = getNumberOfVertices();
if (nv > 3) {
if (!strip) {
int rem = nv % 4;
if (rem != 0) std::cerr << "Quad::drawFunc() - Quad have to have multiple of 4 vertices, add or remove vertices!!" << std::endl;
else {
BEGIN_DLIST
glBegin(GL_QUADS);
ok = true;
}
}
else {
int rem = nv % 2;
if (rem != 0) std::cerr << "Quad::drawFunc() - quad strips have to have multiple of 2 vertices, add or remove vertices!!" << std::endl;
else {
BEGIN_DLIST
glBegin(GL_QUAD_STRIP);
ok = true;
}
}
if (ok) {
// get our regular vertices here
const osg::Vec3* v = getVertices();
const unsigned int ntc = getNumberOfTextureCoords();
// draw with texture
if (ntc > 0 && hasTexture()) {
const osg::Vec2* texCoord = getTextureCoord();
unsigned int tc = 0; // texture count
for (unsigned int i = 0; i < nv; i++) {
// add our textures coordinates
if (tc < ntc) lcTexCoord2v(texCoord[tc++].ptr());
// now our vertices
lcVertex3v( v[i].ptr() );
}
}
// draw without texture
else {
// get our color gradient and apply it (if we have one)
ColorGradient* colGradient = dynamic_cast<ColorGradient*>(getColor());
for (unsigned int i = 0; i < nv; i++) {
if (colGradient != nullptr) {
Basic::Color* col = colGradient->getColorByIdx(i+1);
if (col != nullptr)
glColor4f(static_cast<GLfloat>(col->red()),
static_cast<GLfloat>(col->green()),
static_cast<GLfloat>(col->blue()),
static_cast<GLfloat>(col->alpha()));
}
// now add our vertex
lcVertex3v( v[i].ptr() );
}
}
glEnd();
END_DLIST
}
}
else std::cerr << "Quad::drawFunc() - Quad or QuadStrip needs at least 4 vertices!" << std::endl;