Styjun

I am working on a cloth simulator. It models cloth as a grid of points with spring mass constraints between them. For example, it has similar concepts as described in this tutorial.

For rendering, I am using someone else's code which uses nanogui GLShader objects. It has the option to render a cloth in wireframe, and "smoother" options via two options (the latter is what we're interested in, 'phong' shaders. Here are some relevant code snippets from clothSimulator.h and clothSimulator.cpp:

#ifndef CGL_CLOTH_SIMULATOR_H
#define CGL_CLOTH_SIMULATOR_H

#include <nanogui/nanogui.h>
#include <zmq.hpp>

#include "camera.h"
#include "cloth.h"
#include "collision/collisionObject.h"

using namespace nanogui;

class ClothSimulator {

private:
 virtual void initGUI(Screen *screen);
 void drawWireframe(GLShader &shader);
 void drawNormals(GLShader &shader);
 void drawPhong(GLShader &shader);

 // OpenGL attributes
 enum e_shader WIREFRAME = 0, NORMALS = 1, PHONG = 2 ;
 e_shader activeShader = WIREFRAME;

 vector<GLShader> shaders;
 GLShader wireframeShader;
 GLShader normalShader;
 GLShader phongShader;

// a bunch of other stuff here ...

And in the cpp file:

// a bunch of other stuff above ...

void ClothSimulator::drawPhong(GLShader &shader) 
 int num_tris = cloth->clothMesh->triangles.size();

 MatrixXf positions(3, num_tris * 3); 
 MatrixXf normals(3, num_tris * 3); 

 for (int i = 0; i < num_tris; i++) 
 Triangle *tri = cloth->clothMesh->triangles[i];

 Vector3D p1 = tri->pm1->position;
 Vector3D p2 = tri->pm2->position;
 Vector3D p3 = tri->pm3->position;

 Vector3D n1 = tri->pm1->normal();
 Vector3D n2 = tri->pm2->normal();
 Vector3D n3 = tri->pm3->normal();

 positions.col(i * 3) << p1.x, p1.y, p1.z;
 positions.col(i * 3 + 1) << p2.x, p2.y, p2.z;
 positions.col(i * 3 + 2) << p3.x, p3.y, p3.z;

 normals.col(i * 3) << n1.x, n1.y, n1.z;
 normals.col(i * 3 + 1) << n2.x, n2.y, n2.z;
 normals.col(i * 3 + 2) << n3.x, n3.y, n3.z;
 

 Vector3D cp = camera.position();

 shader.setUniform("in_color", color);
 shader.setUniform("eye", Vector3f(cp.x, cp.y, cp.z));
 shader.setUniform("light", Vector3f(0.5, 2, 2));

 shader.uploadAttrib("in_position", positions);
 shader.uploadAttrib("in_normal", normals);

 shader.drawArray(GL_TRIANGLES, 0, num_tris * 3); 


// a bunch of other stuff below

The general idea appears to be to take all the points, and render them as triangles using the shader methods. It seems like the shader.drawArray method appears to be important. Unfortunately I don't know what options I can supply to it. The documentation for the method appears to be limited, if I am using the right link.

The way I have it now, the cloth renders like this (an example):

However, this renders a very "thin" piece of cloth. I am hoping to increase the thickness of the cloth in the renderer. Should I be adjusting the arguments that I pass to drawArray? Or adjust how I initialize the shader objects themselves? The tutorial I linked to earlier above actually has a part on "quilting" the cloth -- would that be the most straightforward (or only?) solution?

I hope this conveys the basics of what I'm hoping to ask. Please let me know if I can do something to make it easier to understand.