GLC_Light::GLC_Light(LightType lightType, GLC_Context *pContext, const QColor& color)
: GLC_Object("Light")
, m_LightID(-1)
, m_LightType(lightType)
, m_AmbientColor(Qt::black)
, m_DiffuseColor(color)
, m_SpecularColor(Qt::white)
, m_Position()
, m_SpotDirection(0.0, 0.0, -1.0)
, m_SpotExponent(0.0f)
, m_SpotCutoffAngle(180.0f)
, m_ConstantAttenuation(1.0f)
, m_LinearAttenuation(0.0f)
, m_QuadraticAttenuation(0.0f)
, m_TwoSided(false)
, m_pContext(pContext)
, m_Shared(false)
{
addNewLight();
}
GLC_Light::GLC_Light(const GLC_Light& light)
: GLC_Object(light)
, m_LightID(-1)
, m_LightType(light.m_LightType)
, m_AmbientColor(light.m_AmbientColor)
, m_DiffuseColor(light.m_DiffuseColor)
, m_SpecularColor(light.m_SpecularColor)
, m_Position(light.m_Position)
, m_SpotDirection(light.m_SpotDirection)
, m_SpotExponent(light.m_SpotExponent)
, m_SpotCutoffAngle(light.m_SpotCutoffAngle)
, m_ConstantAttenuation(light.m_ConstantAttenuation)
, m_LinearAttenuation(light.m_LinearAttenuation)
, m_QuadraticAttenuation(light.m_QuadraticAttenuation)
, m_TwoSided(light.m_TwoSided)
, m_pContext(light.m_pContext)
, m_Shared(light.m_Shared)
{
addNewLight();
}
void GLC_Light::glExecute()
{
GLC_Context* pCurrentContext= GLC_ContextManager::instance()->currentContext();
Q_ASSERT(NULL != pCurrentContext);
if (NULL == m_pContext)
{
m_pContext= pCurrentContext;
addNewLight();
}
pCurrentContext->glcEnableLighting(true);
pCurrentContext->glcEnableLight(m_LightID);
if (m_pContext != pCurrentContext)
{
Q_ASSERT(QOpenGLContext::areSharing(m_pContext->contextHandle(), pCurrentContext->contextHandle()));
}
Q_ASSERT(m_pContext->contextHandle()->isValid());
GLfloat setArray[4];
// Position
setArray[0]= static_cast<GLfloat>(m_Position.x());
setArray[1]= static_cast<GLfloat>(m_Position.y());
setArray[2]= static_cast<GLfloat>(m_Position.z());
if (LightDirection == m_LightType)
{
setArray[3]= 0.0f;
glLightfv(m_LightID, GL_POSITION, setArray); // Direction of the Light
}
else
{
setArray[3]= 1.0f;
glLightfv(m_LightID, GL_POSITION, setArray); // Position of the Light
}
// Set the lighting model
pCurrentContext->glcSetTwoSidedLight(m_TwoSided);
// Color
setArray[0]= static_cast<GLfloat>(m_AmbientColor.redF());
setArray[1]= static_cast<GLfloat>(m_AmbientColor.greenF());
setArray[2]= static_cast<GLfloat>(m_AmbientColor.blueF());
setArray[3]= static_cast<GLfloat>(m_AmbientColor.alphaF());
glLightfv(m_LightID, GL_AMBIENT, setArray); // Setup The Ambient Light
setArray[0]= static_cast<GLfloat>(m_DiffuseColor.redF());
setArray[1]= static_cast<GLfloat>(m_DiffuseColor.greenF());
setArray[2]= static_cast<GLfloat>(m_DiffuseColor.blueF());
setArray[3]= static_cast<GLfloat>(m_DiffuseColor.alphaF());
glLightfv(m_LightID, GL_DIFFUSE, setArray); // Setup The Diffuse Light
setArray[0]= static_cast<GLfloat>(m_SpecularColor.redF());
setArray[1]= static_cast<GLfloat>(m_SpecularColor.greenF());
setArray[2]= static_cast<GLfloat>(m_SpecularColor.blueF());
setArray[3]= static_cast<GLfloat>(m_SpecularColor.alphaF());
glLightfv(m_LightID, GL_SPECULAR, setArray); // Setup The specular Light
if (LightDirection != m_LightType)
glLightf(m_LightID, GL_CONSTANT_ATTENUATION, m_ConstantAttenuation);
glLightf(m_LightID, GL_LINEAR_ATTENUATION, m_LinearAttenuation);
glLightf(m_LightID, GL_QUADRATIC_ATTENUATION, m_QuadraticAttenuation);
// Spot light parameters
if (LightSpot == m_LightType)
{
// Spot Direction
setArray[0]= static_cast<GLfloat>(m_SpotDirection.x());
setArray[1]= static_cast<GLfloat>(m_SpotDirection.y());
setArray[2]= static_cast<GLfloat>(m_SpotDirection.z());
glLightfv(m_LightID, GL_SPOT_DIRECTION, setArray);
glLightf(m_LightID, GL_SPOT_EXPONENT, m_SpotExponent);
glLightf(m_LightID, GL_SPOT_CUTOFF, m_SpotCutoffAngle);
}
// OpenGL error handler
GLenum error= glGetError();
if (error != GL_NO_ERROR)
{
qDebug() << "GLC_Light::glExecute Exception, id= " << m_LightID;
GLC_OpenGlException OpenGlException("GLC_Light::glExecute ", error);
throw(OpenGlException);
}
}
void LightEditor::menuCallback(cvr::MenuItem * item)
{
// Used later if necessary
//bool isDir, isPoi, isSpo, isAmb, isDif, isSpe, isCon, isLin, isQua, isExp, isCut;
if (item == _createNewLightButton)
{
addNewLight();
osg::Vec4 pos = osg::Vec4(0,500.0,0,1);
if (cvr::ComController::instance()->isMaster())
pos = pos * cvr::PluginHelper::getMouseMat();
else
pos = pos * cvr::PluginHelper::getHandMat();
mLightManager->PhysicalPosition(pos * cvr::PluginHelper::getWorldToObjectTransform());
// Let's also default to point lights
mLightManager->LightType(LightManager::POINT);
}
else if (item == _selectLightList)
{
if (mLightManager->selectLightByName(_selectLightList->getValue()))
updateEditLightMenu();
}
else if (item == _graphicModelsCheckbox)
{
if (_graphicModelsCheckbox->getValue())
mLightManager->enableGraphicModels();
else
mLightManager->disableGraphicModels();
}
else if (item == _saveLightsButton)
{
static std::string lightXmlFile = cvr::ConfigManager::getEntry("value","Plugin.LightEditor.LightXmlFile","");
if (lightXmlFile.empty())
std::cerr << "Attention: No XML filepath given in config file. Cannot save lights until a filepath exists." << std::endl;
else
LightLoader::saveLights(lightXmlFile.c_str(), mLightManager);
}
// Color for Ambient, Diffuse, and Specular
else if (item == _elR || item == _elG || item == _elB)
{
osg::Vec4 (LightManager::*getFunc)();
void (LightManager::*setFunc)(const osg::Vec4);
std::string colorType = _elColorTypeList->getValue();
if (colorType == "Ambient")
{
getFunc = &LightManager::Ambient;
setFunc = &LightManager::Ambient;
}
else if (colorType == "Diffuse")
{
getFunc = &LightManager::Diffuse;
setFunc = &LightManager::Diffuse;
}
else // Specular
{
getFunc = &LightManager::Specular;
setFunc = &LightManager::Specular;
}
if (item == _elR)
{
osg::Vec4 val = (mLightManager->*getFunc)();
val.set(_elR->getValue(), val.y(), val.z(), val.w());
(mLightManager->*setFunc)(val);
}
if (item == _elG)
{
osg::Vec4 val = (mLightManager->*getFunc)();
val.set(val.x(), _elG->getValue(), val.z(), val.w());
(mLightManager->*setFunc)(val);
}
if (item == _elB)
{
osg::Vec4 val = (mLightManager->*getFunc)();
val.set(val.x(), val.y(), _elB->getValue(), val.w());
(mLightManager->*setFunc)(val);
}
}
// Factor for attenuation
else if (item == _elAttenuation)
{
void (LightManager::*setFunc)(const float);
std::string attenuation = _elAttenuationList->getValue();
if (attenuation == "Constant")
{
setFunc = &LightManager::ConstantAttenuation;
}
else if (attenuation == "Linear")
{
setFunc = &LightManager::LinearAttenuation;
}
else // Quadratic
{
setFunc = &LightManager::QuadraticAttenuation;
}
(mLightManager->*setFunc)(_elAttenuation->getValue());
}
// for spot settings
else if (item == _elSpotExponent)
{
mLightManager->SpotExponent(_elSpotExponent->getValue());
}
else if (item == _elSpotCutoff)
{
mLightManager->SpotCutoff(_elSpotCutoff->getValue());
}
// Treat Directional, Point, and Spot buttons as Radio Buttons
else if (item == _elLightTypeList)
{
std::string lightType = _elLightTypeList->getValue();
LightManager::Type type;
if (lightType == "Directional")
type = LightManager::DIRECTIONAL;
else if (lightType == "Spot")
type = LightManager::SPOT;
else // "Point"
type = LightManager::POINT;
mLightManager->LightType(type);
}
if (_elToggleEnable == item)
{
if (_elToggleEnable->getValue())
mLightManager->enableLight();
else
mLightManager->disableLight();
}
// Make sure to update the menu
updateEditLightMenu();
}
