void RenderableLightEntityItem::render(RenderArgs* args) {
PerformanceTimer perfTimer("RenderableLightEntityItem::render");
assert(getType() == EntityTypes::Light);
glm::vec3 position = getPosition();
glm::vec3 dimensions = getDimensions();
glm::quat rotation = getRotation();
float largestDiameter = glm::max(dimensions.x, dimensions.y, dimensions.z);
glm::vec3 color = toGlm(getXColor());
float intensity = getIntensity();
float exponent = getExponent();
float cutoff = glm::radians(getCutoff());
if (_isSpotlight) {
DependencyManager::get<DeferredLightingEffect>()->addSpotLight(position, largestDiameter / 2.0f,
color, intensity, rotation, exponent, cutoff);
} else {
DependencyManager::get<DeferredLightingEffect>()->addPointLight(position, largestDiameter / 2.0f,
color, intensity);
}
#ifdef WANT_DEBUG
Q_ASSERT(args->_batch);
gpu::Batch& batch = *args->_batch;
batch.setModelTransform(getTransformToCenter());
DependencyManager::get<GeometryCache>()->renderWireSphere(batch, 0.5f, 15, 15, glm::vec4(color, 1.0f));
#endif
};
bool DSLightChunk::operator == (const StateChunk &other) const
{
const DSLightChunk *tother = dynamic_cast<const DSLightChunk *>(&other);
if(!tother)
return false;
if(tother == this)
return true;
if(!getAmbient ().equals(tother->getAmbient (),
TypeTraits<Real32>::getDefaultEps()) ||
!getDiffuse ().equals(tother->getDiffuse (),
TypeTraits<Real32>::getDefaultEps()) ||
!getSpecular ().equals(tother->getSpecular (),
TypeTraits<Real32>::getDefaultEps()) ||
!getPosition ().equals(tother->getPosition (),
TypeTraits<Real32>::getDefaultEps()) ||
!getDirection().equals(tother->getDirection(),
TypeTraits<Real32>::getDefaultEps()) ||
getConstantAttenuation () != tother->getConstantAttenuation () ||
getLinearAttenuation () != tother->getLinearAttenuation () ||
getQuadraticAttenuation() != tother->getQuadraticAttenuation() ||
getCutoff () != tother->getCutoff () ||
getExponent () != tother->getExponent ()
)
{
return false;
}
return true;
}
static int checkLowerPowers(int a, int b, int base)
{
int exponent = getExponent(a, base);
if (!exponent) return 0;
b *= exponent;
if (b <= LIMIT) return 1;
int i = 2;
while ((int)pow(base, i) < a) {
if ((b%i == 0) && ((b/i) <= LIMIT)) return 1;
++i;
}
return 0;
}
void LightEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, getIsSpotlight());
APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
APPEND_ENTITY_PROPERTY(PROP_INTENSITY, getIntensity());
APPEND_ENTITY_PROPERTY(PROP_EXPONENT, getExponent());
APPEND_ENTITY_PROPERTY(PROP_CUTOFF, getCutoff());
}
void RenderableLightEntityItem::render(RenderArgs* args) {
PerformanceTimer perfTimer("RenderableLightEntityItem::render");
assert(getType() == EntityTypes::Light);
glm::vec3 position = getPosition();
glm::vec3 dimensions = getDimensions();
glm::quat rotation = getRotation();
float largestDiameter = glm::max(dimensions.x, dimensions.y, dimensions.z);
const float MAX_COLOR = 255.0f;
float colorR = getColor()[RED_INDEX] / MAX_COLOR;
float colorG = getColor()[GREEN_INDEX] / MAX_COLOR;
float colorB = getColor()[BLUE_INDEX] / MAX_COLOR;
glm::vec3 color = glm::vec3(colorR, colorG, colorB);
float intensity = getIntensity();
float exponent = getExponent();
float cutoff = glm::radians(getCutoff());
if (_isSpotlight) {
DependencyManager::get<DeferredLightingEffect>()->addSpotLight(position, largestDiameter / 2.0f,
color, intensity, rotation, exponent, cutoff);
} else {
DependencyManager::get<DeferredLightingEffect>()->addPointLight(position, largestDiameter / 2.0f,
color, intensity);
}
#ifdef WANT_DEBUG
glm::vec4 color(diffuseR, diffuseG, diffuseB, 1.0f);
glPushMatrix();
glTranslatef(position.x, position.y, position.z);
glm::vec3 axis = glm::axis(rotation);
glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
glPushMatrix();
glm::vec3 positionToCenter = center - position;
glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
glScalef(dimensions.x, dimensions.y, dimensions.z);
DependencyManager::get<DeferredLightingEffect>()->renderWireSphere(0.5f, 15, 15, color);
glPopMatrix();
glPopMatrix();
#endif
};
// This method merges the following spec sections for efficiency
// http://www.w3.org/TR/css3-syntax/#consume-a-number
// http://www.w3.org/TR/css3-syntax/#convert-a-string-to-a-number
MediaQueryToken MediaQueryTokenizer::consumeNumber()
{
ASSERT(nextCharsAreNumber());
NumericValueType type = IntegerValueType;
double value = 0;
unsigned offset = 0;
int exponentSign = 1;
unsigned fractionDigits;
int sign = getSign(m_input, offset);
unsigned long long integerPart = getInteger(m_input, offset);
double fractionPart = getFraction(m_input, offset, fractionDigits);
unsigned long long exponentPart = getExponent(m_input, offset, exponentSign);
double exponent = pow(10, (float)exponentSign * (double)exponentPart);
value = (double)sign * ((double)integerPart + fractionPart) * exponent;
m_input.advance(offset);
if (fractionDigits > 0)
type = NumberValueType;
return MediaQueryToken(NumberToken, value, type);
}
void RenderableLightEntityItem::updateRenderItemFromEntity(LightPayload& lightPayload) {
auto entity = this;
lightPayload.setVisible(entity->getVisible());
auto light = lightPayload.editLight();
light->setPosition(entity->getPosition());
light->setOrientation(entity->getRotation());
bool success;
lightPayload.editBound() = entity->getAABox(success);
if (!success) {
lightPayload.editBound() = render::Item::Bound();
}
glm::vec3 dimensions = entity->getDimensions();
float largestDiameter = glm::compMax(dimensions);
light->setMaximumRadius(largestDiameter / 2.0f);
light->setColor(toGlm(entity->getXColor()));
float intensity = entity->getIntensity();//* entity->getFadingRatio();
light->setIntensity(intensity);
light->setFalloffRadius(entity->getFalloffRadius());
float exponent = entity->getExponent();
float cutoff = glm::radians(entity->getCutoff());
if (!entity->getIsSpotlight()) {
light->setType(model::Light::POINT);
} else {
light->setType(model::Light::SPOT);
light->setSpotAngle(cutoff);
light->setSpotExponent(exponent);
}
}
// This method merges the following spec sections for efficiency
// http://www.w3.org/TR/css3-syntax/#consume-a-number
// http://www.w3.org/TR/css3-syntax/#convert-a-string-to-a-number
CSSParserToken CSSTokenizer::consumeNumber()
{
ASSERT(nextCharsAreNumber());
NumericValueType type = IntegerValueType;
double value = 0;
unsigned offset = 0;
int exponentSign = 1;
NumericSign sign = getSign(m_input, offset);
double integerPart = getInteger(m_input, offset);
unsigned integerPartEndOffset = offset;
double fractionPart = getFraction(m_input, offset);
double exponentPart = getExponent(m_input, offset, exponentSign);
double exponent = pow(10, (float)exponentSign * (double)exponentPart);
value = ((double)integerPart + fractionPart) * exponent;
if (sign == MinusSign)
value = -value;
m_input.advance(offset);
if (offset != integerPartEndOffset)
type = NumberValueType;
return CSSParserToken(NumberToken, value, type, sign);
}
double Fl_Gto::getCoulombnormalized(const int s, const int p, const int l,
const int m, const int n) const {
assert((0 <= s) && (s < static_cast<int>(this->cgto.size())));
assert((0 <= p) && (p < static_cast<int>(this->cgto[s].contraction())));
assert(l >= 0);
assert(m >= 0);
assert(n >= 0);
// assert((l +m +n) < MaxAngular);
// check consistent with shell.
int maxangular = 0;
switch (this->getShell(s)) {
case 's':
maxangular = 0;
break;
case 'p':
maxangular = 1;
break;
case 'd':
maxangular = 2;
break;
case 'f':
maxangular = 3;
break;
default:
CnErr.abort("Fl_Gto", "", "double getNormalized(int,int,int,int,int)",
"not support over f angular momentum, sorry.");
break;
}
if (l + m + n > maxangular) {
CnErr.abort("Fl_Gto", "", "double getNormalized(int,int,int,int,int)",
"illegal angular momentum, inconsistent with shell.");
}
// calculate normalized factor of pGTO, of which angular part is X^l Y^m Z^n
// type.
TlMath Math;
const int angular = l + m + n;
double ans = 0.0;
switch (angular) {
case 0:
/* s type pGTO */
ans = std::pow(2.0, -1.0 / 4.0);
ans *= std::pow(Math.PI() / getExponent(s, p), -5.0 / 4.0);
break;
case 1:
/* px, py, pz type pGTO */
ans = std::pow(2.0, -1.0 / 4.0);
ans *= std::pow(Math.PI() / getExponent(s, p), -5.0 / 4.0);
ans *= std::pow(12.0 * getExponent(s, p), 1.0 / 2.0);
break;
case 2:
if (l == 2 || m == 2 || n == 2) {
/* dxx, dyy, dzz type pGTO */
ans = std::pow(2.0, -1.0 / 4.0);
ans *= std::pow(Math.PI() / getExponent(s, p), -5.0 / 4.0);
ans *=
std::pow(60.0 * 4.0 * getExponent(s, p) * getExponent(s, p) / 49.0,
1.0 / 2.0);
} else {
/* dxy, dyz, dzx type pGTO */
ans = std::pow(2.0, -1.0 / 4.0);
ans *= std::pow(Math.PI() / getExponent(s, p), -5.0 / 4.0);
ans *= std::pow(4.0 * 20.0 * getExponent(s, p) * getExponent(s, p),
1.0 / 2.0);
}
break;
default:
CnErr.abort("Fl_Gto", "", "double getNormalized(int,int,int,int,int)",
"not support over d angular momentum, sorry.(H6/05/27)");
break;
}
return ans;
}
