mirror of
https://github.com/introlab/rtabmap_ros.git
synced 2026-10-04 08:47:45 +08:00
Tango: Added Settings/Optimized Mesh/Sketchfab Upload
This commit is contained in:
matlabbe
@@ -46,6 +46,7 @@ PointCloudDrawable::PointCloudDrawable(
|
||||
nPoints_(0),
|
||||
pose_(1.0f),
|
||||
visible_(true),
|
||||
hasNormals_(false),
|
||||
cloud_shader_program_(cloudShaderProgram),
|
||||
texture_shader_program_(textureShaderProgram),
|
||||
gain_(1.0f)
|
||||
@@ -63,6 +64,7 @@ PointCloudDrawable::PointCloudDrawable(
|
||||
nPoints_(0),
|
||||
pose_(1.0f),
|
||||
visible_(true),
|
||||
hasNormals_(false),
|
||||
cloud_shader_program_(cloudShaderProgram),
|
||||
texture_shader_program_(textureShaderProgram),
|
||||
gain_(1.0f)
|
||||
@@ -90,19 +92,20 @@ PointCloudDrawable::~PointCloudDrawable()
|
||||
|
||||
void PointCloudDrawable::updatePolygons(const std::vector<pcl::Vertices> & polygons)
|
||||
{
|
||||
LOGD("Update polygons");
|
||||
polygons_.clear();
|
||||
if(polygons.size() && organizedToDenseIndices_.size())
|
||||
{
|
||||
int polygonSize = polygons[0].vertices.size();
|
||||
unsigned int polygonSize = polygons[0].vertices.size();
|
||||
UASSERT(polygonSize == 3);
|
||||
polygons_.resize(polygons.size() * polygonSize);
|
||||
int oi = 0;
|
||||
for(unsigned int i=0; i<polygons.size(); ++i)
|
||||
{
|
||||
UASSERT((int)polygons[i].vertices.size() == polygonSize);
|
||||
for(int j=0; j<polygonSize; ++j)
|
||||
UASSERT(polygons[i].vertices.size() == polygonSize);
|
||||
for(unsigned int j=0; j<polygonSize; ++j)
|
||||
{
|
||||
polygons_[oi++] = organizedToDenseIndices_.at((unsigned short)polygons[i].vertices[j]);
|
||||
polygons_[oi++] = organizedToDenseIndices_.at(polygons[i].vertices[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -110,7 +113,7 @@ void PointCloudDrawable::updatePolygons(const std::vector<pcl::Vertices> & polyg
|
||||
|
||||
void PointCloudDrawable::updateCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud, const pcl::IndicesPtr & indices, float gain)
|
||||
{
|
||||
UASSERT(cloud.get() && !cloud->empty() && indices.get() && !indices->empty());
|
||||
UASSERT(cloud.get() && !cloud->empty());
|
||||
nPoints_ = 0;
|
||||
polygons_.clear();
|
||||
gain_ = gain;
|
||||
@@ -137,13 +140,31 @@ void PointCloudDrawable::updateCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Pt
|
||||
}
|
||||
|
||||
LOGI("Creating cloud buffer %d", vertex_buffers_);
|
||||
std::vector<float> vertices(indices->size()*4);
|
||||
for(unsigned int i=0; i<indices->size(); ++i)
|
||||
std::vector<float> vertices;
|
||||
int totalPoints = 0;
|
||||
if(indices.get() && indices->size())
|
||||
{
|
||||
vertices[i*4] = cloud->at(indices->at(i)).x;
|
||||
vertices[i*4+1] = cloud->at(indices->at(i)).y;
|
||||
vertices[i*4+2] = cloud->at(indices->at(i)).z;
|
||||
vertices[i*4+3] = cloud->at(indices->at(i)).rgb;
|
||||
totalPoints = indices->size();
|
||||
vertices.resize(indices->size()*4);
|
||||
for(unsigned int i=0; i<indices->size(); ++i)
|
||||
{
|
||||
vertices[i*4] = cloud->at(indices->at(i)).x;
|
||||
vertices[i*4+1] = cloud->at(indices->at(i)).y;
|
||||
vertices[i*4+2] = cloud->at(indices->at(i)).z;
|
||||
vertices[i*4+3] = cloud->at(indices->at(i)).rgb;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
totalPoints = cloud->size();
|
||||
vertices.resize(cloud->size()*4);
|
||||
for(unsigned int i=0; i<cloud->size(); ++i)
|
||||
{
|
||||
vertices[i*4] = cloud->at(i).x;
|
||||
vertices[i*4+1] = cloud->at(i).y;
|
||||
vertices[i*4+2] = cloud->at(i).z;
|
||||
vertices[i*4+3] = cloud->at(i).rgb;
|
||||
}
|
||||
}
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
|
||||
@@ -158,12 +179,12 @@ void PointCloudDrawable::updateCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Pt
|
||||
return;
|
||||
}
|
||||
|
||||
nPoints_ = indices->size();
|
||||
nPoints_ = totalPoints;
|
||||
}
|
||||
|
||||
void PointCloudDrawable::updateMesh(const Mesh & mesh, const cv::Mat & texture)
|
||||
{
|
||||
UASSERT(mesh.cloud.get() && !mesh.cloud->empty() && mesh.indices.get() && !mesh.indices->empty());
|
||||
UASSERT(mesh.cloud.get() && !mesh.cloud->empty());
|
||||
nPoints_ = 0;
|
||||
|
||||
if (vertex_buffers_)
|
||||
@@ -196,7 +217,6 @@ void PointCloudDrawable::updateMesh(const Mesh & mesh, const cv::Mat & texture)
|
||||
|
||||
if(textureUpdate)
|
||||
{
|
||||
UASSERT(!mesh.cloud->is_dense);
|
||||
glGenTextures(1, &textures_);
|
||||
if(!textures_)
|
||||
{
|
||||
@@ -206,39 +226,155 @@ void PointCloudDrawable::updateMesh(const Mesh & mesh, const cv::Mat & texture)
|
||||
}
|
||||
}
|
||||
|
||||
LOGI("Creating cloud buffer %d", vertex_buffers_);
|
||||
LOGD("Creating cloud buffer %d", vertex_buffers_);
|
||||
std::vector<float> vertices;
|
||||
organizedToDenseIndices_ = std::vector<int>(mesh.cloud->width*mesh.cloud->height, -1);
|
||||
if(textures_)
|
||||
int totalPoints = 0;
|
||||
std::vector<pcl::Vertices> polygons = mesh.polygons;
|
||||
hasNormals_ = mesh.normals.get() && mesh.normals->size() == mesh.cloud->size();
|
||||
UASSERT(!hasNormals_ || mesh.cloud->size() == mesh.normals->size());
|
||||
if(mesh.cloud->isOrganized()) // assume organized mesh
|
||||
{
|
||||
vertices = std::vector<float>(mesh.indices->size()*6);
|
||||
for(unsigned int i=0; i<mesh.indices->size(); ++i)
|
||||
organizedToDenseIndices_ = std::vector<unsigned int>(mesh.cloud->width*mesh.cloud->height, -1);
|
||||
totalPoints = mesh.indices->size();
|
||||
if(textures_ && polygons.size())
|
||||
{
|
||||
vertices[i*6] = mesh.cloud->at(mesh.indices->at(i)).x;
|
||||
vertices[i*6+1] = mesh.cloud->at(mesh.indices->at(i)).y;
|
||||
vertices[i*6+2] = mesh.cloud->at(mesh.indices->at(i)).z;
|
||||
LOGD("Organized mesh with texture");
|
||||
int items = hasNormals_?9:6;
|
||||
vertices = std::vector<float>(mesh.indices->size()*9);
|
||||
for(unsigned int i=0; i<mesh.indices->size(); ++i)
|
||||
{
|
||||
vertices[i*items] = mesh.cloud->at(mesh.indices->at(i)).x;
|
||||
vertices[i*items+1] = mesh.cloud->at(mesh.indices->at(i)).y;
|
||||
vertices[i*items+2] = mesh.cloud->at(mesh.indices->at(i)).z;
|
||||
|
||||
// rgb
|
||||
vertices[i*6+3] = mesh.cloud->at(mesh.indices->at(i)).rgb;
|
||||
// rgb
|
||||
vertices[i*items+3] = mesh.cloud->at(mesh.indices->at(i)).rgb;
|
||||
|
||||
// texture uv
|
||||
int index = mesh.indices->at(i);
|
||||
vertices[i*6+4] = float(index % mesh.cloud->width)/float(mesh.cloud->width); //u
|
||||
vertices[i*6+5] = float(index / mesh.cloud->width)/float(mesh.cloud->height); //v
|
||||
// texture uv
|
||||
int index = mesh.indices->at(i);
|
||||
vertices[i*items+4] = float(index % mesh.cloud->width)/float(mesh.cloud->width); //u
|
||||
vertices[i*items+5] = float(index / mesh.cloud->width)/float(mesh.cloud->height); //v
|
||||
|
||||
organizedToDenseIndices_[mesh.indices->at(i)] = i;
|
||||
if(hasNormals_)
|
||||
{
|
||||
// normal
|
||||
vertices[i*items+6] = mesh.normals->at(mesh.indices->at(i)).normal_x;
|
||||
vertices[i*items+7] = mesh.normals->at(mesh.indices->at(i)).normal_y;
|
||||
vertices[i*items+8] = mesh.normals->at(mesh.indices->at(i)).normal_z;
|
||||
}
|
||||
|
||||
organizedToDenseIndices_[mesh.indices->at(i)] = i;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGD("Organized mesh");
|
||||
int items = hasNormals_?7:4;
|
||||
vertices = std::vector<float>(mesh.indices->size()*items);
|
||||
for(unsigned int i=0; i<mesh.indices->size(); ++i)
|
||||
{
|
||||
vertices[i*items] = mesh.cloud->at(mesh.indices->at(i)).x;
|
||||
vertices[i*items+1] = mesh.cloud->at(mesh.indices->at(i)).y;
|
||||
vertices[i*items+2] = mesh.cloud->at(mesh.indices->at(i)).z;
|
||||
vertices[i*items+3] = mesh.cloud->at(mesh.indices->at(i)).rgb;
|
||||
|
||||
if(hasNormals_)
|
||||
{
|
||||
// normal
|
||||
vertices[i*items+4] = mesh.normals->at(mesh.indices->at(i)).normal_x;
|
||||
vertices[i*items+5] = mesh.normals->at(mesh.indices->at(i)).normal_y;
|
||||
vertices[i*items+6] = mesh.normals->at(mesh.indices->at(i)).normal_z;
|
||||
}
|
||||
|
||||
organizedToDenseIndices_[mesh.indices->at(i)] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
else // assume dense mesh with texCoords set to polygons
|
||||
{
|
||||
vertices = std::vector<float>(mesh.indices->size()*4);
|
||||
for(unsigned int i=0; i<mesh.indices->size(); ++i)
|
||||
totalPoints = mesh.cloud->size();
|
||||
if(textures_ && polygons.size() && mesh.normals->size())
|
||||
{
|
||||
vertices[i*4] = mesh.cloud->at(mesh.indices->at(i)).x;
|
||||
vertices[i*4+1] = mesh.cloud->at(mesh.indices->at(i)).y;
|
||||
vertices[i*4+2] = mesh.cloud->at(mesh.indices->at(i)).z;
|
||||
vertices[i*4+3] = mesh.cloud->at(mesh.indices->at(i)).rgb;
|
||||
organizedToDenseIndices_[mesh.indices->at(i)] = i;
|
||||
LOGD("Dense mesh with texture (%d texCoords %d points %d polygons %dx%d)",
|
||||
(int)mesh.texCoords.size(), (int)mesh.cloud->size(), (int)mesh.polygons.size(), texture.cols, texture.rows);
|
||||
|
||||
// Texturing issue:
|
||||
// tex_coordinates should be linked to points, not
|
||||
// polygon vertices. Points linked to multiple different texCoords (different textures) should
|
||||
// be duplicated.
|
||||
vertices = std::vector<float>(mesh.texCoords.size()*9);
|
||||
organizedToDenseIndices_ = std::vector<unsigned int>(mesh.texCoords.size(), -1);
|
||||
|
||||
UASSERT_MSG(mesh.texCoords.size() == polygons[0].vertices.size()*polygons.size(),
|
||||
uFormat("%d vs %d x %d", (int)mesh.texCoords.size(), (int)polygons[0].vertices.size(), (int)polygons.size()).c_str());
|
||||
|
||||
int items = hasNormals_?9:6;
|
||||
unsigned int oi=0;
|
||||
for(unsigned int i=0; i<polygons.size(); ++i)
|
||||
{
|
||||
pcl::Vertices & v = polygons[i];
|
||||
for(unsigned int j=0; j<v.vertices.size(); ++j)
|
||||
{
|
||||
UASSERT(oi < mesh.texCoords.size());
|
||||
UASSERT(v.vertices[j] < mesh.cloud->size());
|
||||
|
||||
vertices[oi*items] = mesh.cloud->at(v.vertices[j]).x;
|
||||
vertices[oi*items+1] = mesh.cloud->at(v.vertices[j]).y;
|
||||
vertices[oi*items+2] = mesh.cloud->at(v.vertices[j]).z;
|
||||
|
||||
// rgb
|
||||
vertices[oi*items+3] = mesh.cloud->at(v.vertices[j]).rgb;
|
||||
|
||||
// texture uv
|
||||
if(mesh.texCoords[oi][0]>=0.0f)
|
||||
{
|
||||
vertices[oi*items+4] = mesh.texCoords[oi][0]; //u
|
||||
vertices[oi*items+5] = 1.0f-mesh.texCoords[oi][1]; //v
|
||||
}
|
||||
else
|
||||
{
|
||||
vertices[oi*items+4] = vertices[oi*items+5] = -1.0f;
|
||||
}
|
||||
|
||||
if(hasNormals_)
|
||||
{
|
||||
// normal
|
||||
vertices[oi*items+6] = mesh.normals->at(v.vertices[j]).normal_x;
|
||||
vertices[oi*items+7] = mesh.normals->at(v.vertices[j]).normal_y;
|
||||
vertices[oi*items+8] = mesh.normals->at(v.vertices[j]).normal_z;
|
||||
}
|
||||
|
||||
v.vertices[j] = (int)oi; // new vertex index
|
||||
|
||||
UASSERT(oi < organizedToDenseIndices_.size());
|
||||
organizedToDenseIndices_[oi] = oi;
|
||||
|
||||
++oi;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGD("Dense mesh");
|
||||
int items = hasNormals_?7:4;
|
||||
organizedToDenseIndices_ = std::vector<unsigned int>(mesh.cloud->size(), -1);
|
||||
vertices = std::vector<float>(mesh.cloud->size()*items);
|
||||
for(unsigned int i=0; i<mesh.cloud->size(); ++i)
|
||||
{
|
||||
vertices[i*items] = mesh.cloud->at(i).x;
|
||||
vertices[i*items+1] = mesh.cloud->at(i).y;
|
||||
vertices[i*items+2] = mesh.cloud->at(i).z;
|
||||
vertices[i*items+3] = mesh.cloud->at(i).rgb;
|
||||
|
||||
if(hasNormals_)
|
||||
{
|
||||
vertices[i*items+4] = mesh.normals->at(i).normal_x;
|
||||
vertices[i*items+5] = mesh.normals->at(i).normal_y;
|
||||
vertices[i*items+6] = mesh.normals->at(i).normal_z;
|
||||
}
|
||||
|
||||
organizedToDenseIndices_[i] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -256,6 +392,10 @@ void PointCloudDrawable::updateMesh(const Mesh & mesh, const cv::Mat & texture)
|
||||
|
||||
if(textures_ && textureUpdate)
|
||||
{
|
||||
GLint maxTextureSize = 0;
|
||||
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
|
||||
LOGI("maxTextureSize=%d", maxTextureSize);
|
||||
|
||||
// gen texture from image
|
||||
glBindTexture(GL_TEXTURE_2D, textures_);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
@@ -276,11 +416,11 @@ void PointCloudDrawable::updateMesh(const Mesh & mesh, const cv::Mat & texture)
|
||||
}
|
||||
}
|
||||
|
||||
nPoints_ = mesh.indices->size();
|
||||
nPoints_ = totalPoints;
|
||||
|
||||
if(polygons_.size() != mesh.polygons.size())
|
||||
if(polygons_.size() != polygons.size())
|
||||
{
|
||||
updatePolygons(mesh.polygons);
|
||||
updatePolygons(polygons);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -291,7 +431,12 @@ void PointCloudDrawable::setPose(const rtabmap::Transform & pose)
|
||||
pose_ = glmFromTransform(pose);
|
||||
}
|
||||
|
||||
void PointCloudDrawable::Render(const glm::mat4 & projectionMatrix, const glm::mat4 & viewMatrix, bool meshRendering, float pointSize, bool textureRendering) {
|
||||
void PointCloudDrawable::Render(const glm::mat4 & projectionMatrix,
|
||||
const glm::mat4 & viewMatrix,
|
||||
bool meshRendering,
|
||||
float pointSize,
|
||||
bool textureRendering,
|
||||
bool lighting) {
|
||||
|
||||
if(vertex_buffers_ && nPoints_ && visible_)
|
||||
{
|
||||
@@ -299,65 +444,144 @@ void PointCloudDrawable::Render(const glm::mat4 & projectionMatrix, const glm::m
|
||||
{
|
||||
glUseProgram(texture_shader_program_);
|
||||
|
||||
GLuint mvp_handle_ = glGetUniformLocation(texture_shader_program_, "mvp");
|
||||
glm::mat4 mvp_mat = projectionMatrix * viewMatrix * pose_;
|
||||
glUniformMatrix4fv(mvp_handle_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
|
||||
GLuint mvp_handle = glGetUniformLocation(texture_shader_program_, "uMVP");
|
||||
glm::mat4 mv_mat = viewMatrix * pose_;
|
||||
glm::mat4 mvp_mat = projectionMatrix * mv_mat;
|
||||
glUniformMatrix4fv(mvp_handle, 1, GL_FALSE, glm::value_ptr(mvp_mat));
|
||||
|
||||
GLuint n_handle = glGetUniformLocation(texture_shader_program_, "uN");
|
||||
glm::mat3 normalMatrix(mv_mat);
|
||||
normalMatrix = glm::inverse(normalMatrix);
|
||||
normalMatrix = glm::transpose(normalMatrix);
|
||||
glUniformMatrix3fv(n_handle, 1, GL_FALSE, glm::value_ptr(normalMatrix));
|
||||
|
||||
if(!hasNormals_)
|
||||
{
|
||||
lighting = false;
|
||||
}
|
||||
|
||||
//lighting
|
||||
GLuint lighting_handle = glGetUniformLocation(texture_shader_program_, "uUseLighting");
|
||||
glUniform1i(lighting_handle, lighting?1:0);
|
||||
|
||||
if(lighting)
|
||||
{
|
||||
GLuint ambiant_handle = glGetUniformLocation(texture_shader_program_, "uAmbientColor");
|
||||
glUniform3f(ambiant_handle,0.6,0.6,0.6);
|
||||
|
||||
GLuint lightingDirection_handle = glGetUniformLocation(texture_shader_program_, "uLightingDirection");
|
||||
glUniform3f(lightingDirection_handle, 0.0, 0.0, 1.0); // from the camera
|
||||
}
|
||||
|
||||
// Texture activate unit 0
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
// Bind the texture to this unit.
|
||||
glBindTexture(GL_TEXTURE_2D, textures_);
|
||||
// Tell the texture uniform sampler to use this texture in the shader by binding to texture unit 0.
|
||||
GLuint texture_handle = glGetUniformLocation(texture_shader_program_, "u_Texture");
|
||||
GLuint texture_handle = glGetUniformLocation(texture_shader_program_, "uTexture");
|
||||
glUniform1i(texture_handle, 0);
|
||||
|
||||
GLuint gain_handle = glGetUniformLocation(texture_shader_program_, "u_gain");
|
||||
GLuint gain_handle = glGetUniformLocation(texture_shader_program_, "uGain");
|
||||
glUniform1f(gain_handle, gain_);
|
||||
|
||||
GLint attribute_vertex = glGetAttribLocation(texture_shader_program_, "vertex");
|
||||
GLint attribute_texture = glGetAttribLocation(texture_shader_program_, "a_TexCoordinate");
|
||||
GLint attribute_vertex = glGetAttribLocation(texture_shader_program_, "aVertex");
|
||||
GLint attribute_texture = glGetAttribLocation(texture_shader_program_, "aTexCoord");
|
||||
GLint attribute_normal=0;
|
||||
if(hasNormals_)
|
||||
{
|
||||
attribute_normal = glGetAttribLocation(texture_shader_program_, "aNormal");
|
||||
}
|
||||
|
||||
glEnableVertexAttribArray(attribute_vertex);
|
||||
glEnableVertexAttribArray(attribute_texture);
|
||||
if(hasNormals_)
|
||||
{
|
||||
glEnableVertexAttribArray(attribute_normal);
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_texture, 2, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (GLvoid*) (4 * sizeof(GLfloat)));
|
||||
|
||||
glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_SHORT, polygons_.data());
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, (hasNormals_?9:6)*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_texture, 2, GL_FLOAT, GL_FALSE, (hasNormals_?9:6)*sizeof(GLfloat), (GLvoid*) (4 * sizeof(GLfloat)));
|
||||
if(hasNormals_)
|
||||
{
|
||||
glVertexAttribPointer(attribute_normal, 3, GL_FLOAT, GL_FALSE, 9*sizeof(GLfloat), (GLvoid*) (6 * sizeof(GLfloat)));
|
||||
}
|
||||
glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_INT, polygons_.data());
|
||||
}
|
||||
else // point cloud or colored mesh
|
||||
{
|
||||
glUseProgram(cloud_shader_program_);
|
||||
|
||||
GLuint mvp_handle_ = glGetUniformLocation(cloud_shader_program_, "mvp");
|
||||
glm::mat4 mvp_mat = projectionMatrix * viewMatrix * pose_;
|
||||
GLuint mvp_handle_ = glGetUniformLocation(cloud_shader_program_, "uMVP");
|
||||
glm::mat4 mv_mat = viewMatrix * pose_;
|
||||
glm::mat4 mvp_mat = projectionMatrix * mv_mat;
|
||||
glUniformMatrix4fv(mvp_handle_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
|
||||
|
||||
GLuint point_size_handle_ = glGetUniformLocation(cloud_shader_program_, "point_size");
|
||||
GLuint n_handle = glGetUniformLocation(texture_shader_program_, "uN");
|
||||
glm::mat3 normalMatrix(mv_mat);
|
||||
normalMatrix = glm::inverse(normalMatrix);
|
||||
normalMatrix = glm::transpose(normalMatrix);
|
||||
glUniformMatrix3fv(n_handle, 1, GL_FALSE, glm::value_ptr(normalMatrix));
|
||||
|
||||
if(!hasNormals_)
|
||||
{
|
||||
lighting = false;
|
||||
}
|
||||
|
||||
//lighting
|
||||
GLuint lighting_handle = glGetUniformLocation(texture_shader_program_, "uUseLighting");
|
||||
glUniform1i(lighting_handle, lighting?1:0);
|
||||
|
||||
if(lighting)
|
||||
{
|
||||
GLuint ambiant_handle = glGetUniformLocation(texture_shader_program_, "uAmbientColor");
|
||||
glUniform3f(ambiant_handle,0.6,0.6,0.6);
|
||||
|
||||
GLuint lightingDirection_handle = glGetUniformLocation(texture_shader_program_, "uLightingDirection");
|
||||
glUniform3f(lightingDirection_handle, 0.0, 0.0, 1.0); // from the camera
|
||||
}
|
||||
|
||||
GLuint point_size_handle_ = glGetUniformLocation(cloud_shader_program_, "uPointSize");
|
||||
glUniform1f(point_size_handle_, pointSize);
|
||||
|
||||
GLuint gain_handle = glGetUniformLocation(cloud_shader_program_, "u_gain");
|
||||
GLuint gain_handle = glGetUniformLocation(cloud_shader_program_, "uGain");
|
||||
glUniform1f(gain_handle, gain_);
|
||||
|
||||
GLint attribute_vertex = glGetAttribLocation(cloud_shader_program_, "vertex");
|
||||
GLint attribute_color = glGetAttribLocation(cloud_shader_program_, "color");
|
||||
GLint attribute_vertex = glGetAttribLocation(cloud_shader_program_, "aVertex");
|
||||
GLint attribute_color = glGetAttribLocation(cloud_shader_program_, "aColor");
|
||||
GLint attribute_normal=0;
|
||||
if(hasNormals_)
|
||||
{
|
||||
attribute_normal = glGetAttribLocation(cloud_shader_program_, "aNormal");
|
||||
}
|
||||
|
||||
glEnableVertexAttribArray(attribute_vertex);
|
||||
glEnableVertexAttribArray(attribute_color);
|
||||
if(hasNormals_)
|
||||
{
|
||||
glEnableVertexAttribArray(attribute_normal);
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
|
||||
if(textures_)
|
||||
{
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, 6*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, (hasNormals_?9:6)*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, (hasNormals_?9:6)*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
|
||||
if(hasNormals_)
|
||||
{
|
||||
glVertexAttribPointer(attribute_normal, 3, GL_FLOAT, GL_FALSE, 9*sizeof(GLfloat), (GLvoid*) (6 * sizeof(GLfloat)));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, 4*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
|
||||
glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, (hasNormals_?7:4)*sizeof(GLfloat), 0);
|
||||
glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, (hasNormals_?7:4)*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
|
||||
if(hasNormals_)
|
||||
{
|
||||
glVertexAttribPointer(attribute_normal, 3, GL_FLOAT, GL_FALSE, 7*sizeof(GLfloat), (GLvoid*) (4 * sizeof(GLfloat)));
|
||||
}
|
||||
}
|
||||
if(meshRendering && polygons_.size())
|
||||
{
|
||||
glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_SHORT, polygons_.data());
|
||||
glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_INT, polygons_.data());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user