void
GiLightObject::insertPointBefore(int idx)
{
if (idx == 0)
{
Vec v = m_points[0]-m_points[1];
v += m_points[0];
m_points.insert(0, v);
setPointPressed(0);
}
else
{
Vec v = (m_points[idx]+m_points[idx-1])/2;
m_points.insert(idx, v);
setPointPressed(idx);
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
GiLightObject&
GiLightObject::operator=(const GiLightObject &po)
{
//m_pointPressed = -1;
m_pointPressed = po.m_pointPressed;
m_updateFlag = true; // for recomputation
m_lightChanged = true; // for light recomputation
m_showPointNumbers = po.m_showPointNumbers;
m_showPoints = po.m_showPoints;
m_segments = po.m_segments;
m_color = po.m_color;
m_opacity = po.m_opacity;
m_lod = po.m_lod;
m_smooth = po.m_smooth;
m_points = po.m_points;
m_allowInterpolate = po.m_allowInterpolate;
m_doShadows = po.m_doShadows;
m_lightType = po.m_lightType;
m_rad = po.m_rad;
m_decay = po.m_decay;
m_angle = po.m_angle;
m_show = po.m_show;
computeTangents();
m_undo.clear();
m_undo.append(m_points);
return *this;
}
void
GiLightObject::setGiLightObjectInfo(GiLightObjectInfo glo)
{
m_pointPressed = -1;
m_points.clear();
m_points = glo.points;
m_allowInterpolate = glo.allowInterpolation;
m_doShadows = glo.doShadows;
m_show = glo.show;
m_lightType = glo.lightType;
m_rad = glo.rad;
m_decay = glo.decay;
m_angle = glo.angle;
m_color = glo.color;
m_opacity = glo.opacity;
m_segments = glo.segments;
m_lod = glo.lod;
m_smooth = glo.smooth;
m_pointPressed = -1;
computeTangents();
m_undo.clear();
m_undo.append(m_points);
m_updateFlag = true;
m_lightChanged = true;
}
void
GiLightObject::insertPointAfter(int idx)
{
int npts = m_points.count();
if (idx == npts-1)
{
Vec v = m_points[npts-1]-m_points[npts-2];
v += m_points[npts-1];
m_points.append(v);
setPointPressed(npts-1);
}
else
{
Vec v = (m_points[idx]+m_points[idx+1])/2;
m_points.insert(idx+1, v);
setPointPressed(idx+1);
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void
GiLightObject::translate(bool moveX, bool indir)
{
QList<Vec> delta;
int npoints = m_points.count();
for (int i=0; i<npoints; i++)
{
if (moveX)
delta << m_pathX[i*m_segments];
else
delta << m_pathY[i*m_segments];
}
if (indir)
{
for(int i=0; i<npoints; i++)
m_points[i] += delta[i];
}
else
{
for(int i=0; i<npoints; i++)
m_points[i] -= delta[i];
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void
GiLightObject::makeCircle()
{
int npoints = m_points.count();
if (npoints < 3)
return;
Vec cen = m_points[0];
for(int i=1; i<npoints; i++)
cen += m_points[i];
cen /= npoints;
float avgD = 0;
for(int i=1; i<npoints; i++)
avgD += (m_points[i]-cen).norm();
avgD /= npoints;
// now shift all points into the plane
for(int i=0; i<npoints; i++)
{
Vec v0 = (m_points[i]-cen);
if (v0.squaredNorm() > 0.0)
{
v0.normalize();
m_points[i] = cen + avgD*v0;
}
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void
GiLightObject::makePlanar(int v0, int v1, int v2)
{
int npoints = m_points.count();
if (npoints < 3)
return;
Vec cen = m_points[0];
for(int i=1; i<npoints; i++)
cen += m_points[i];
cen /= npoints;
Vec normal;
normal = (m_points[v0]-m_points[v1]).unit()^(m_points[v2]-m_points[v1]).unit();
normal.normalize();
// now shift all points into the plane
for(int i=0; i<npoints; i++)
{
Vec v0 = m_points[i]-cen;
float dv = normal*v0;
m_points[i] -= dv*normal;
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void
GiLightObject::redo()
{
m_undo.redo();
m_points = m_undo.points();
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
}
void
GiLightObject::addPoint(Vec pt)
{
m_points.append(pt);
m_pointPressed = -1;
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void GiLightObject::setPoint(int i, Vec pt)
{
if (i >= 0 && i < m_points.count())
{
m_points[i] = pt;
computeTangents();
}
else
{
for(int j=0; j<m_points.count(); j++)
m_points[j] += pt;
}
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
}
void
GiLightObject::removePoint(int idx)
{
if (m_points.count() <= 1 ||
idx >= m_points.count())
return;
m_pointPressed = -1;
m_points.removeAt(idx);
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void GiLightObject::setPoints(QList<Vec> pts)
{
m_pointPressed = -1;
// if (pts.count() < 2)
// {
// QMessageBox::information(0, QString("%1 points").arg(pts.count()),
// "Number of points must be greater than 1");
// return;
// }
m_points = pts;
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
void
GiLightObject::translate(int idx, int moveType, float mag)
{
int npoints = m_points.count();
if (moveType == 0) // move along y-axis
{
if (idx<0 || idx>=npoints)
{
for(int i=0; i<npoints; i++)
m_points[i] += mag*m_pathY[i*m_segments];
}
else
m_points[idx] += mag*m_pathY[idx*m_segments];
}
else if (moveType == 1) // move along x-axis
{
if (idx<0 || idx>=npoints)
{
for(int i=0; i<npoints; i++)
m_points[i] += mag*m_pathX[i*m_segments];
}
else
m_points[idx] += mag*m_pathX[idx*m_segments];
}
else // move along tangent
{
if (idx<0 || idx>=npoints)
{
for(int i=0; i<npoints; i++)
m_points[i] += mag*m_pathT[i*m_segments];
}
else
m_points[idx] += mag*m_pathT[idx*m_segments];
}
computeTangents();
m_updateFlag = true;
m_lightChanged = true; // for light recomputation
m_undo.append(m_points);
}
VertexPTNT* VertexData::getVertexPTNT() {
if(vertex_ptnt != NULL) {
return vertex_ptnt;
}
if( ! (attribs & (VERT_POS | VERT_NORM | VERT_TEX | VERT_TAN)) ) {
return NULL;
}
if(tangents.size() == 0) {
computeTangents();
}
int num = getNumVertices();
vertex_ptnt = new VertexPTNT[num];
for(int i = 0; i < num; ++i) {
vertex_ptnt[i].pos = vertices[i];
vertex_ptnt[i].norm = normals[i];
vertex_ptnt[i].tex = texcoords[i];
vertex_ptnt[i].tan = tangents[i];
}
return vertex_ptnt;
}
// --------========--------========--------========--------========--------========--------========
void TweenedLinearCurve::loadFromXmlNode(xmlNodePtr root, float keyDifferenceToIgnore )
{
// look for the curve asset (we only take the first one)
xmlNodePtr child = root->children;
while (child)
{
if (xmlStrcmp( child->name, (const xmlChar*)"PreLoop") == 0)
{
std::string content = XML::parseString(child, "value");
this->setPreLoop( curveLoopTypeFromString(content) );
#if _DEBUG
printf("PreLoop -> got content! [%s] = preLoop[%d]\n", content.c_str(), (int)getPreLoop());
#endif
}
else if (xmlStrcmp( child->name, (const xmlChar*)"PostLoop") == 0)
{
std::string content = XML::parseString(child, "value");
this->setPostLoop( curveLoopTypeFromString(content) );
#ifdef _DEBUG
printf("PostLoop -> got content! [%s] = postLoop[%d]\n", content.c_str(), (int)getPostLoop());
#endif
}
if (xmlStrcmp( child->name, (const xmlChar*)"Keys") == 0)
{
xmlNodePtr key = child->children;
float lastAddedCurveKeyValue=0;
bool didNotAddLastCurveKey=false;
CurveKey lastCurveKey;
EasingFunction lastTweeningFunction;
while(key)
{
if(xmlStrcmp( key->name, (const xmlChar*)"Key") == 0)
{
float position = XML::parseFloat(key, "position");
float value = XML::parseFloat(key, "value");
CurveKey ck(position, value, 0.0f, 0.0f);
EasingFunction tweeningFunction;
if(XML::attrExists(key, "tween"))
{
std::string tween = XML::parseString(key, "tween");
float tweenValue = XML::parseFloat(key, "tweenValue");
tweeningFunction = Tweens::getEasingFunctionForString(tween,tweenValue);
}
else
{
tweeningFunction = &Tweens::linearTween;
}
bool shouldAddCurveKey=true;
if(absf(value-lastAddedCurveKeyValue)<keyDifferenceToIgnore &&
mKeys.size() )
{
shouldAddCurveKey=false;
didNotAddLastCurveKey=true;
lastCurveKey=ck;
lastTweeningFunction=tweeningFunction;
Logger::printf("Walaber", Logger::SV_DEBUG, "Keys -> not adding curvekey! value: [%f] last value: [%f] key difference to ignore: [%f]\n", value, lastAddedCurveKeyValue, keyDifferenceToIgnore);
}
else if(didNotAddLastCurveKey)
{
Logger::printf("Walaber", Logger::SV_DEBUG, "Keys -> got content! position: [%f] value: [%f]\n", lastCurveKey.getPosition(), lastCurveKey.getValue());
addCurveKey(lastCurveKey);
mTweeningFunctions.push_back(lastTweeningFunction);
}
if(shouldAddCurveKey)
{
lastAddedCurveKeyValue=value;
didNotAddLastCurveKey=false;
#ifdef _DEBUG
printf("Keys -> got content! position: [%f] value: [%f]\n", position, value);
#endif
addCurveKey(ck);
mTweeningFunctions.push_back(tweeningFunction);
}
}
key = key->next;
}
if( didNotAddLastCurveKey )
{
addCurveKey( lastCurveKey );
mTweeningFunctions.push_back(lastTweeningFunction);
}
_computeDurations();
computeTangents();
}
child = child->next;
}
}
void CVK::Geometry::createBuffers()
{
m_points = m_vertices.size();
m_indices = m_index.size();
// create the buffers and bind the data
if ( m_vertexbuffer == INVALID_OGL_VALUE)
{
glGenBuffers(1, &m_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, m_points * sizeof(glm::vec4), &m_vertices[0], GL_STATIC_DRAW);
}
if ( m_normalbuffer == INVALID_OGL_VALUE && m_normals.size()>0)
{
glGenBuffers(1, &m_normalbuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_normalbuffer);
glBufferData(GL_ARRAY_BUFFER, m_points * sizeof(glm::vec3), &m_normals[0], GL_STATIC_DRAW);
}
if ( m_uvbuffer == INVALID_OGL_VALUE && m_uvs.size()>0)
{
glGenBuffers(1, &m_uvbuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_uvbuffer);
glBufferData(GL_ARRAY_BUFFER, m_points * sizeof(glm::vec2), &m_uvs[0], GL_STATIC_DRAW);
}
if ( m_tangentbuffer == INVALID_OGL_VALUE && m_uvs.size()>0)
{
if(m_tangents.empty())
{
computeTangents();
}
glGenBuffers(1, &m_tangentbuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_tangentbuffer);
glBufferData(GL_ARRAY_BUFFER, m_tangents.size() * sizeof(glm::vec3), &m_tangents[0], GL_STATIC_DRAW);
}
// Generate a buffer for the indices as well
if (m_indexlist == INVALID_OGL_VALUE)
{
glGenBuffers(1, &m_indexlist);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexlist);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices * sizeof(unsigned int), &m_index[0] , GL_STATIC_DRAW);
}
if (m_vao == INVALID_OGL_VALUE)
glGenVertexArrays(1, &m_vao);
glBindVertexArray(m_vao);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexbuffer);
glEnableVertexAttribArray(VERTICES);
glVertexAttribPointer( VERTICES, 4, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_normalbuffer);
glEnableVertexAttribArray(NORMALS);
glVertexAttribPointer(NORMALS, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_uvbuffer);
glEnableVertexAttribArray(TEXTURECOORDS);
glVertexAttribPointer(TEXTURECOORDS, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_tangentbuffer);
glEnableVertexAttribArray(TANGENTS);
glVertexAttribPointer(TANGENTS, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexlist);
glBindVertexArray(0);
glDisableVertexAttribArray(VERTICES);
glDisableVertexAttribArray(NORMALS);
glDisableVertexAttribArray(TEXTURECOORDS);
glDisableVertexAttribArray(TANGENTS);
}
