MeshData MeshUtils::makeRectangle(vec3 v0, vec3 v1, vec3 v2, vec3 v3,
vec3 t0, vec3 t1, vec3 t2, vec3 t3) {
MeshData m;
//m.create();
vec3 n = glm::cross(v0 - v1, v2 - v0); //to do: double check direction...
n = glm::normalize(n);
const vec3 vs[] = { v0, v1, v2, v3 };
const vec3 ns[] = { n, n, n, n };
const vec3 ts[] = { t0, t1, t2, t3 };
const unsigned int indices[] = { 0,1,2, 2,1,3 };
//static const unsigned int indices[] = { 0,1,2, 1,2,3 };
m.vertex(vs, 4);
m.normal(ns, 4);
m.texCoord(ts, 4);
m.index(indices, 6);
/*
cout << "v0 : " << to_string(vs[0]) << "\n";
cout << "v1 : " << to_string(vs[1]) << "\n";
cout << "v2 : " << to_string(vs[2]) << "\n";
cout << "v3 : " << to_string(vs[3]) << "\n";
cout << "n0 : " << to_string(ns[0]) << "\n";
cout << "n1 : " << to_string(ns[1]) << "\n";
cout << "n2 : " << to_string(ns[2]) << "\n";
cout << "n3 : " << to_string(ns[3]) << "\n";
// exit(0);
*/
return m;
}
void CreateScreenQuad(
MeshData& Quad)
{
AttribData<vec3> Vertices(4);
Vertices.Set(0, vec3(-1.0f, -1.0f, 0.0f));
Vertices.Set(1, vec3( 1.0f, -1.0f, 0.0f));
Vertices.Set(2, vec3( 1.0f, 1.0f, 0.0f));
Vertices.Set(3, vec3(-1.0f, 1.0f, 0.0f));
AttribData<vec2> TexCoords(4);
TexCoords.Set(0, vec2(0.0f, 0.0f));
TexCoords.Set(1, vec2(1.0f, 0.0f));
TexCoords.Set(2, vec2(1.0f, 1.0f));
TexCoords.Set(3, vec2(0.0f, 1.0f));
AttribData<GLFace16> Faces(2);
Faces.Set(0, GLFace16(0, 1, 2) );
Faces.Set(1, GLFace16(2, 3, 0) );
Polygons Polylist1;
Polylist1.SetMaterial(0);
Polylist1.SetFaces(Faces);
AttribData<poly> Polygons(1);
Polygons.Set(0, Polylist1);
Quad.SetVertexArray(Vertices);
Quad.SetUVArray(TexCoords);
Quad.SetPolygonList(Polygons);
Quad.GenerateNormals(false);
Quad.GenerateTangents();
}
MeshData *TetGenCaller::CopyTetMesh(tetgenio *io)
{
MeshData *NewMesh = new MeshData(this->Mesh->BoundingBox);
// Add vertices
for (int i = 0; i < io->numberofpoints; i++) {
double *c;
c = &io->pointlist[3 * i];
NewMesh->VertexOctreeRoot->AddVertex(c[0], c[1], c[2]);
}
// Add triangles
for (int i = 0; i < io->numberoftrifaces; i++) {
int *triface;
int marker = io->trifacemarkerlist[i];
triface = &io->trifacelist[3 * i];
TriangleType *t = NewMesh->AddTriangle({triface[0], triface[1], triface[2]});
t->InterfaceID = marker;
}
// Add tetrahedrons
for (int i = 0; i < io->numberoftetrahedra; i++) {
int *tet = &io->tetrahedronlist[4 * i];
TetType *t = NewMesh->AddTetrahedron({tet[0], tet[1], tet[2], tet[3]});
if (io->numberoftetrahedronattributes == 1) {
int tetattr = io->tetrahedronattributelist[i];
t->MaterialID = tetattr;
} else {
t->MaterialID = 0;
}
}
return NewMesh;
}
void Renderer::unproject(int width, int height, string filename, MeshData &meshData, bool lighting, double* output)
{
engine = new EngineOSG();
double *A = new double[9];
double *R = new double[9];
double *T = new double[3];
engine->setParams(width, height, NULL, NULL, filename, 0, 0,
0, 0, false, /*NULL, NULL, NULL*/A,R,T, output, meshData, "",
true, NULL, NULL, NULL, lighting, 50, "zxy", true);
engine->init();
try
{
if (meshData.getVertices().empty()) {
engine->initDataFromFile();
} else {
engine->initData();
}
meshData.copy(engine->getMeshData());
engine->initCamera();
engine->initCanvas();
engine->InitFrame();
}
catch (char const *e)
{
engine->shutdown();
delete engine;
throw e;
}
}
void Renderer::run(int width, int height, double *depthOutput, unsigned char * imageOutput, string filename,
double distance, double elevation, double azimuth, double yaw, bool sphereOrientation,
double *A, double *R, double *T, double *unprojectOutput, MeshData &meshData,
string writeFiles, bool offScreen, double *AOutput, double *ROutput, double *TOutput,
bool lighting, double distanceInc, string deg_order, bool getUnproject) {
engine = new EngineOSG();
engine->setParams(width, height, depthOutput, imageOutput, filename, distance, elevation,
azimuth, yaw, sphereOrientation, A, R, T, unprojectOutput, meshData, writeFiles,
offScreen, AOutput, ROutput, TOutput, lighting, distanceInc, deg_order, getUnproject);
engine->init();
try
{
if (meshData.getVertices().empty()) {
engine->initDataFromFile();
} else {
engine->initData();
}
meshData.copy(engine->getMeshData());
engine->initCamera();
engine->initCanvas();
engine->draw();
engine->draw(); // double draw since some models require 2 frames to build up properly
}
catch (char const *e)
{
engine->shutdown();
delete engine;
throw e;
}
engine->shutdown();
delete engine;
}
bool DirectxEngine::UpdateShader(const MeshData& mesh,
const IScene& scene,
bool alphaBlend,
float timer)
{
const int index = mesh.ShaderID();
if (index != NO_INDEX)
{
auto& shader = m_data->shaders[index];
if(index != m_data->selectedShader)
{
SetSelectedShader(index);
SendLights(scene.Lights());
shader->UpdateConstantMatrix("viewProjection", m_data->viewProjection);
shader->UpdateConstantFloat("cameraPosition", &m_data->cameraPosition.x, 3);
shader->UpdateConstantFloat("depthNear", &scene.Post().DepthNear(), 1);
shader->UpdateConstantFloat("depthFar", &scene.Post().DepthFar(), 1);
if (index == WATER_SHADER)
{
shader->UpdateConstantFloat("timer", &timer, 1);
}
}
SendTextures(mesh.TextureIDs());
SetRenderState(mesh.BackfaceCull(), m_data->isWireframe);
EnableAlphaBlending(alphaBlend, false);
return true;
}
return false;
}
void MeshUtils::addPoint(MeshData &m, vec3 v) {
const vec3 vs[] = { v };
unsigned int off = (unsigned int) m.indices().size();
const unsigned int indices[] = { off };
m.vertex(vs, 1);
m.index(indices, 1);
}
MeshData MeshUtils::makeGrid(int cols, int rows, vec2 vLL, vec2 vUR) { //needs to be rendered via drawTriangleStrip
float xl = vLL.x;
float yl = vLL.y;
float xu = vUR.x;
float yu = vUR.y;
MeshData m;
vec3* vs = new vec3[cols * rows];
GLuint* is = new GLuint [(cols*2*(rows-1)+2*(rows-2))];
for (int y =0; y<rows; y++) {
for (int x=0; x < cols ; x++) {
vs[cols*y+x].x= xl +x*(xu-xl)/(float)(cols-1.0);
vs[cols*y+x].y= yl +y*(yu-yl)/(float)(rows-1.0);
vs[cols*y+x].z = 0.0f;
}
}
// Index data
int q = 0;
for (int y =0; y<rows-1; y++) {
for (int x=0; x < cols ; x++) {
is[q] = x + y*cols;
q++;
is[q] = x + (y+1)*cols;
q++;
}
if( y < rows-2){ // the degenerate triangles
//repeating last one
is[q] = (cols-1) + (y+1)*cols;
q++;
//repeating next one
is[q] = (y+1)*cols;
q++;
}
}
m.vertex(vs,cols*rows);
m.index(is, cols*2*(rows-1)+2*(rows-2));
delete vs;
delete is;
return m;
}
void initScene()
{
string modelPath = ASSET_PATH + MODEL_PATH + "/armoredrecon.fbx";
loadFBXFromFile(modelPath, ¤tMesh);
//Generate Vertex Array
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, currentMesh.getNumVerts()*sizeof(Vertex), ¤tMesh.vertices[0], GL_STATIC_DRAW);
//create buffer
glGenBuffers(1, &EBO);
//Make the EBO active
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
//Copy Index data to the EBO
glBufferData(GL_ELEMENT_ARRAY_BUFFER, currentMesh.getNumIndices()*sizeof(int), ¤tMesh.indices[0], GL_STATIC_DRAW);
//Tell the shader that 0 is the position element
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), NULL);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void**)(sizeof(vec3)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void**)(sizeof(vec3) + sizeof(vec4)));
GLuint vertexShaderProgram = 0;
string vsPath = ASSET_PATH + SHADER_PATH + "/simpleVS.glsl";
vertexShaderProgram = loadShaderFromFile(vsPath, VERTEX_SHADER);
checkForCompilerErrors(vertexShaderProgram);
GLuint fragmentShaderProgram = 0;
string fsPath = ASSET_PATH + SHADER_PATH + "/simpleFS.glsl";
fragmentShaderProgram = loadShaderFromFile(fsPath, FRAGMENT_SHADER);
checkForCompilerErrors(fragmentShaderProgram);
shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShaderProgram);
glAttachShader(shaderProgram, fragmentShaderProgram);
//Link attributes
glBindAttribLocation(shaderProgram, 0, "vertexPosition");
glBindAttribLocation(shaderProgram, 1, "vertexColour");
glBindAttribLocation(shaderProgram, 2, "vertexTexCoords");
glLinkProgram(shaderProgram);
checkForLinkErrors(shaderProgram);
//now we can delete the VS & FS Programs
glDeleteShader(vertexShaderProgram);
glDeleteShader(fragmentShaderProgram);
}
void DataListCtrl::EndEdit(bool update)
{
if (!m_rename_text->IsShown())
return;
if (update)
{
wxString new_name = m_rename_text->GetValue();
long item = GetNextItem(-1,
wxLIST_NEXT_ALL,
wxLIST_STATE_SELECTED);
VRenderFrame* vr_frame = (VRenderFrame*)m_frame;
DataManager* mgr = vr_frame?vr_frame->GetDataManager():0;
if (item != -1 && mgr)
{
wxString name = GetText(item, 1);
if (new_name != name)
{
wxString new_name2 = new_name;
for (int i=1; mgr->CheckNames(new_name2); i++)
new_name2 = new_name+wxString::Format("_%d", i);
if (GetItemText(item) == "Volume")
{
VolumeData* vd = mgr->GetVolumeData(name);
if (vd)
vd->SetName(new_name2);
}
else if (GetItemText(item) == "Mesh")
{
MeshData* md = mgr->GetMeshData(name);
if (md)
md->SetName(new_name2);
}
else if (GetItemText(item) == "Annotations")
{
Annotations* ann = mgr->GetAnnotations(name);
if (ann)
ann->SetName(new_name2);
}
//update ui
SetText(item, 1, new_name2);
vr_frame->UpdateTree();
}
}
}
m_rename_text->Hide();
}
void DynamicRenderable::wipeBuffers()
{
oht_assert_threadmodel(ThrMdl_Single);
// TODO: Is this necessary now that we employ latent render operations?
_renderOp.vertexData->vertexBufferBinding->unsetAllBindings();
for (size_t l = 0; l < getNumLevels(); ++l)
{
MeshData * pMeshData = _pvMeshData[l];
if (pMeshData != NULL)
pMeshData->clear();
}
}
Mesh* Mesh::create(const std::vector<float>& vertices, int perVertexSizeInFloat, const IndexArray& indices, const std::vector<MeshVertexAttrib>& attribs)
{
MeshData meshdata;
meshdata.attribs = attribs;
meshdata.vertex = vertices;
meshdata.subMeshIndices.push_back(indices);
meshdata.subMeshIds.push_back("");
auto meshvertexdata = MeshVertexData::create(meshdata);
auto indexbuffer = IndexBuffer::create(IndexBuffer::IndexType::INDEX_TYPE_SHORT_16, (int)indices.size());
AABB aabb = MeshVertexData::calculateAABB(meshdata.vertex, meshdata.getPerVertexSize(), indices);
auto indexData = MeshIndexData::create("", meshvertexdata, indexbuffer, aabb);
return create("", indexData);
}
std::unique_ptr<VboMesh> PolygonStyleBuilder::build() {
auto mesh = std::make_unique<Mesh>(m_style.vertexLayout(), m_style.drawMode());
mesh->compile(m_meshData);
m_meshData.clear();
return std::move(mesh);
}
void GeometryBufferData::Append(MeshData data)
{
IndexOffsetData appendData;
appendData.baseVertexOffset = vertices.size();
appendData.baseIndexOffset = indices.size();
appendData.indexCount = data.indices.size();
if (data.getId() >= indexData.size())
{
indexData.resize(data.getId() + 10);
}
indexData[data.getId()] = appendData;
vertices.insert(vertices.end(), data.vertices.begin(), data.vertices.end());
indices.insert(indices.end(), data.indices.begin(), data.indices.end());
}
MeshData ResourceManager::AssimpProcessScene(aiNode* node, const aiScene* scene)
{
MeshData data;
for (UINT i = 0; i < node->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[i];
data.Append(AssimpProcessMesh(mesh, scene));
}
for (UINT i = 0; i < node->mNumChildren; i++)
{
AssimpProcessScene(node->mChildren[i], scene);
}
return data;
}
MeshData* loadMeshData(const char* filename){
char* aux = strchr (filename, '.');
aux++;
MeshData *ret;
if ((strcmp (aux, "md2") == 0) || (strcmp (aux, "MD2") == 0)){
ret = new MD2Obj();
ret->load(filename);
ret->setMeshType(MD2MESH);
return ret;
}else if ((strcmp (aux, "obj") == 0) || (strcmp (aux, "OBJ") == 0)){
ret = new ObjData();
ret->load(filename);
ret->setMeshType(OBJMESH);
return ret;
}
return NULL;
}
void MeshUtils::addTriangle(MeshData &m, vec3 v0, vec3 v1, vec3 v2,
vec3 t0, vec3 t1, vec3 t2) {
vec3 n = glm::cross(v1 - v0, v2 - v0);
const vec3 vs[] = { v0, v1, v2 };
const vec3 ns[] = { n, n, n };
const vec3 ts[] = { t0, t1, t2 };
unsigned int off = (unsigned int) m.indices().size();
const unsigned int indices[] = { off,off+1,off+2 };
m.vertex(vs, 3);
m.normal(ns, 3);
m.texCoord(ts, 3);
m.index(indices, 3);
}
void MeshAppearanceTemplate::parseVertexData(IffStream* iffStream, int idx) {
int formVersion = 0;'0000';// + idx;
String idxText = String::valueOf(idx);
int lengthOfText = idxText.length();
for (int i = 0; i < 4 - lengthOfText; ++i)
idxText = "0" + idxText;
for (int i = 0; i < 4; ++i) {
char a = idxText.charAt(i);
formVersion = formVersion << 8;
formVersion += (int)a;
}
iffStream->openForm(formVersion);
iffStream->openChunk('NAME');
String shaderName;
iffStream->getString(shaderName);
iffStream->closeChunk();
iffStream->openChunk('INFO');
iffStream->closeChunk();
uint32 nextVersion = iffStream->getNextFormType();
iffStream->openForm(nextVersion);
iffStream->openChunk('INFO');
iffStream->closeChunk();
MeshData meshData;
meshData.readObject(iffStream);
meshes->add(meshData);
iffStream->closeForm(nextVersion);
iffStream->closeForm(formVersion);
}
void CreatePatch(
MeshData& Mesh)
{
Mesh.SetName("Patch");
AttribData<vec3> aVertex;// = MeshArray.SetVertexArray();
aVertex.Resize(4);
aVertex.Set(0, vec3(-10.0f, 0.0f,-10.0f));
aVertex.Set(1, vec3(-10.0f, 0.0f, 10.0f));
aVertex.Set(2, vec3( 10.0f, 0.0f,-10.0f));
aVertex.Set(3, vec3( 10.0f, 0.0f, 10.0f));
Mesh.SetVertexArray(aVertex);
AttribData<vec2> aTexCoords;// = MeshArray.SetUVArray();
aTexCoords.Resize(4);
aTexCoords.Set(0, glm::vec2( 0.0f, 0.0f));
aTexCoords.Set(1, glm::vec2( 0.0f, 1.0f));
aTexCoords.Set(2, glm::vec2( 1.0f, 0.0f));
aTexCoords.Set(3, glm::vec2( 1.0f, 1.0f));
Mesh.SetUVArray(aTexCoords);
AttribData<vec3> aNormal;// = MeshArray.SetNormalArray();
aNormal.Resize(4);
aNormal.Set(0, vec3(0.0f, 1.0f, 0.0f));
aNormal.Set(1, vec3(0.0f, 1.0f, 0.0f));
aNormal.Set(2, vec3(0.0f, 1.0f, 0.0f));
aNormal.Set(3, vec3(0.0f, 1.0f, 0.0f));
Mesh.SetNormalArray(aNormal);
AttribData<vec3> aTangent;// = MeshArray.SetTangentArray();
aTangent.Resize(4);
aTangent.Set(0, vec3(1.0f, 0.0f, 0.0f));
aTangent.Set(1, vec3(1.0f, 0.0f, 0.0f));
aTangent.Set(2, vec3(1.0f, 0.0f, 0.0f));
aTangent.Set(3, vec3(1.0f, 0.0f, 0.0f));
Mesh.SetTangentArray(aTangent.GetBufferPointer(), aTangent.Size());
AttribData<vec3> aBitangent;// = MeshArray.SetBitangentArray();
aBitangent.Resize(4);
aBitangent.Set(0, vec3(0.0f, 0.0f, 1.0f));
aBitangent.Set(1, vec3(0.0f, 0.0f, 1.0f));
aBitangent.Set(2, vec3(0.0f, 0.0f, 1.0f));
aBitangent.Set(3, vec3(0.0f, 0.0f, 1.0f));
Mesh.SetBitangentArray(aBitangent);
AttribData<Polygons> aFaces;// = MeshArray.SetPolygonArray();
Polygons polys;
polys.SetMaterial(0);
polys.SetFaces().Resize(2);
polys.SetFaces().Set(0, GLFace16(0, 1, 2));
polys.SetFaces().Set(1, GLFace16(0, 2, 3));
aFaces.Resize(1);
aFaces.Set(0, polys);
Mesh.SetPolygonList(aFaces);
}
RE::MeshData RE::FileSystem::ProcessAssimpScene(const aiNode *node, const aiScene *scene)
{
MeshData data;
XMMATRIX T = XMLoadFloat4x4(reinterpret_cast<const DirectX::XMFLOAT4X4 *>(&node->mTransformation));
for (uint32_t i = 0; i < node->mNumMeshes; ++i)
{
size_t meshIndex = static_cast<size_t>(node->mMeshes[i]);
MeshData tempData = ProcessAssimpMesh(scene->mMeshes[meshIndex], T);
data.Append(tempData);
}
for (uint32_t i = 0; i < node->mNumChildren; ++i)
{
MeshData tempData = ProcessAssimpScene(node->mChildren[i], scene);
data.Append(tempData);
}
return data;
}
MeshData MeshUtils::makeTriangle(vec3 v0, vec3 v1, vec3 v2,
vec3 t0, vec3 t1, vec3 t2) {
MeshData m;
vec3 n = glm::cross(v1 - v0, v2 - v0);
const vec3 vs[] = { v0, v1, v2 };
const vec3 ns[] = { n, n, n };
const vec3 ts[] = { t0, t1, t2 };
const unsigned int indices[] = { 0,1,2 };
m.vertex(vs, 3);
m.normal(ns, 3);
m.texCoord(ts, 3);
m.index(indices, 3);
return m;
}
void CreateDiamond(
MeshData& Diamond)
{
Diamond.SetName("Diamond");
AttribData<vec3> Vertices; Vertices.Resize(6);
Vertices.Set(0, vec3( 0.0f, 0.5f, 0.0f ));
Vertices.Set(1, vec3( 0.5f, 0.0f, 0.0f ));
Vertices.Set(2, vec3( 0.0f, 0.0f,-0.5f ));
Vertices.Set(3, vec3(-0.5f, 0.0f, 0.0f ));
Vertices.Set(4, vec3( 0.0f, 0.0f, 0.5f ));
Vertices.Set(5, vec3( 0.0f,-0.5f, 0.0f ));
AttribData<vec3> Normals; Normals.Resize(6);
Normals.Set(0, vec3( 0.0f, 1.0f, 0.0f ));
Normals.Set(1, vec3( 1.0f, 0.0f, 0.0f ));
Normals.Set(2, vec3( 0.0f, 0.0f,-1.0f ));
Normals.Set(3, vec3(-1.0f, 0.0f, 0.0f ));
Normals.Set(4, vec3( 0.0f, 0.0f, 1.0f ));
Normals.Set(5, vec3( 0.0f,-1.0f, 0.0f ));
AttribData<vec2> TexCoords; TexCoords.Resize(6);
TexCoords.Set(0, vec2(0.5f, 1.0f) );
TexCoords.Set(1, vec2(0.0f, 0.5f) );
TexCoords.Set(2, vec2(0.25f, 0.5f) );
TexCoords.Set(3, vec2(0.5f, 0.5f) );
TexCoords.Set(4, vec2(0.75f, 0.5f) );
TexCoords.Set(5, vec2(0.5f, 0.0f) );
AttribData<GLFace16> Faces; Faces.Resize(8);
Faces.Set(0, GLFace16(0, 1, 2) );
Faces.Set(1, GLFace16(0, 2, 3) );
Faces.Set(2, GLFace16(0, 3, 4) );
Faces.Set(3, GLFace16(0, 4, 1) );
Faces.Set(4, GLFace16(5, 2, 1) );
Faces.Set(5, GLFace16(5, 3, 2) );
Faces.Set(6, GLFace16(5, 4, 3) );
Faces.Set(7, GLFace16(5, 1, 4) );
Polygons Polylist1;
Polylist1.SetMaterial(0);
Polylist1.SetFaces(Faces);
AttribData<poly> Polygons;
Polygons.Resize(1);
Polygons.Set(0, Polylist1);
Diamond.SetName("DiamondMesh");
Diamond.SetVertexArray(Vertices);
Diamond.SetUVArray(TexCoords);
Diamond.GenerateNormals(false);
Diamond.GenerateTangents();
Diamond.SetPolygonList(Polygons);
}
SkinnedMesh::SkinnedMesh(DevicePtr dptr, const MeshData& mesh_data) :
_triangle_buffer(dptr, mesh_data.triangles().size()),
_vertex_buffer(dptr, mesh_data.skinned_vertices().size()),
_indirect_data(mesh_data.triangles().size() * 3, 1),
_skeleton(mesh_data.bones()),
_radius(mesh_data.radius()) {
CmdBufferRecorder recorder(dptr->create_disposable_cmd_buffer());
Mapping::stage(_triangle_buffer, recorder, mesh_data.triangles().data());
Mapping::stage(_vertex_buffer, recorder, mesh_data.skinned_vertices().data());
dptr->graphic_queue().submit<SyncSubmit>(RecordedCmdBuffer(std::move(recorder)));
}
void setup(){
bindGLV();
gui(amt,"amt",-100,100); //<-- amt of transform
gui(wt,"wt",-100,100); //<-- wt of diff
gui(bUseCotan,"bUseCotan"); //<-- use TWOPI deficit formula
gui(bExterior,"bExterior"); //<-- use vector derivatives then exterior
gui(bExteriorDerivativeNormals,"bExteriorDerivativeNormals");
gui(bExteriorDerivative,"bExteriorDerivative");
gui(bFullDerivative,"bFullDerivative");
gui(bDivideByArea,"bDivideByArea"); //<-- use vector derivatives then exterior
gui(bDrawMean,"bDrawMean"); //<-- draw mean color (vs gaussian)
gui(bDrawNormals,"bDrawNormals"); //<-- draw normals
gui(bDrawReciprocals,"bDrawReciprocals"); //<-- draw normals
//0. set starting parameters
wt = 1.0;
amt = 1.0;
bDrawNormals = true;
scene.camera.pos(0,0,10);
//1. Generate SpaceGroup Tessellate, Hang on lattice, Graph
int w=20; int h=w;
SpaceGroup2D<Vec> sg(3,1,true);
auto tmp = sg.hang( point(0,0,0), w, h);
for(auto& i : tmp){
mesh.add( MyData(i));
}
mesh.store();
graph.UV(w,h,mesh);
//2. per node, add simplices
for(auto& i : graph.node() ){
int num = i->valence().size();
i->data().simplex = vector<Simplicial2>(num);
}
}
//Переделать в будущем. Пусть метод берет примитивы из менеджера ресурсов, а когда их нет, то записывает их туда же и отдает.
MeshData* Renderer::GetMeshDataPrimitive(std::string name)
{
MeshData* data = 0;
std::map<std::string, MeshData*>::iterator it;
it = meshPrimitives.find(name);
if (it != meshPrimitives.end())
{
data = it->second;
}
else
{//Примитив не нашелся, пытаемся создать
if (name == "plane")
{
data = new MeshData();
//Заполнить мешдату
std::vector<float> vertices;
vertices.push_back(-0.5f); vertices.push_back(-0.5f); vertices.push_back(0.0f);
vertices.push_back(0.5f); vertices.push_back(-0.5f); vertices.push_back(0.0f);
vertices.push_back(0.5f); vertices.push_back(0.5f); vertices.push_back(0.0f);
vertices.push_back(-0.5f); vertices.push_back(0.5f); vertices.push_back(0.0f);
data->FillPosition(vertices);
std::vector<float> uvw;
uvw.push_back(0.0f); uvw.push_back(0.0f); uvw.push_back(0.0f);
uvw.push_back(1.0f); uvw.push_back(0.0f); uvw.push_back(0.0f);
uvw.push_back(1.0f); uvw.push_back(1.0f); uvw.push_back(0.0f);
uvw.push_back(0.0f); uvw.push_back(1.0f); uvw.push_back(0.0f);
data->FillUVW(uvw);
std::vector<unsigned short> indices;
indices.push_back(0); indices.push_back(1); indices.push_back(3);
indices.push_back(1); indices.push_back(2); indices.push_back(3);
data->FillIndices(indices);
}
}
return data;
}
void CreateScreen(
ModelData& ScreenMesh)
{
MeshData Screen;
AttribData<vec3> Screen_vert;
Screen_vert.Resize(4);
Screen_vert.Set(0, vec3(-1.0f, 1.0f, 1.0f)); // lu-corner
Screen_vert.Set(1, vec3( 1.0f, 1.0f, 1.0f)); // ru-corner
Screen_vert.Set(2, vec3(-1.0f, -1.0f, 1.0f)); // bl-corner
Screen_vert.Set(3, vec3( 1.0f, -1.0f, 1.0f)); // br-corner
AttribData<vec2> Screen_UVs;
Screen_UVs.Resize(4);
Screen_UVs.Set(0, vec2(0.0f, 0.0f));
Screen_UVs.Set(1, vec2(0.0f, 1.0f));
Screen_UVs.Set(2, vec2(1.0f, 0.0f));
Screen_UVs.Set(3, vec2(1.0f, 1.0f));
AttribData<GLFace16> Screen_face;
Screen_face.Resize(2);
Screen_face.Set(0, GLFace16(0, 1, 2));
Screen_face.Set(1, GLFace16(1, 3, 2));
Polygons polys;
polys.SetFaces(Screen_face);
polys.SetMaterial(0);
AttribData<Polygons> polygons;
polygons.Resize(1);
polygons.Set(0, polys);
Screen.SetName("Screen");
Screen.SetVertexArray(Screen_vert);
Screen.SetUVArray(Screen_UVs);
Screen.SetPolygonList(polygons);
Screen.GenerateNormals(false);
Screen.GenerateTangents();
MaterialData Screen_mat;
Screen_mat.MaterialType = HasRenderedTexture;
Library<MaterialData> lib_mat;
lib_mat.Resize(1);
lib_mat.Set(0, Screen_mat);
Library<MeshData> lib_mesh;
lib_mesh.Resize(1);
lib_mesh.Set(0, Screen);
ScreenMesh.SetMeshData(lib_mesh);
ScreenMesh.SetMaterialData(lib_mat);
}
void Renderer::Show(int width, int height, string filename, double distance, double elevation, double azimuth, double yaw,
MeshData &meshData, bool lighting)
{
engine = new EngineOSG();
double *A = new double[9];
double *R = new double[9];
double *T = new double[3];
engine->setParams(width, height, NULL, NULL, filename, distance, elevation,
azimuth, yaw, true, /*NULL, NULL, NULL*/A,R,T, NULL, meshData, "",
false, NULL, NULL, NULL, lighting, 50, "zxy", false);
engine->init();
try
{
if (meshData.getVertices().empty()) {
engine->initDataFromFile();
} else {
engine->initData();
}
meshData.copy(engine->getMeshData());
engine->initCamera();
engine->initCanvas();
engine->InitFrame();
engine->frame();
}
catch (char const *e)
{
engine->shutdown();
delete engine;
throw e;
}
}
bool DirectxEngine::UpdateShader(const MeshData& quad)
{
const int index = quad.ShaderID();
if (index != NO_INDEX)
{
auto& shader = m_data->shaders[index];
if(index != m_data->selectedShader)
{
SetSelectedShader(index);
shader->UpdateConstantMatrix("viewProjection", m_data->viewProjection);
}
SetRenderState(false, m_data->isWireframe);
EnableAlphaBlending(true, true);
return true;
}
return false;
}
void render()
{
//old imediate mode!
//Set the clear colour(background)
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//clear the colour and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shaderProgram);
GLint MVPLocation = glGetUniformLocation(shaderProgram, "MVP");
glUniformMatrix4fv(MVPLocation, 1, GL_FALSE, glm::value_ptr(MVPMatrix));
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, currentMesh.getNumIndices(), GL_UNSIGNED_INT, 0);
}
bool MeshEditHandler::mouseDoubleClickEvent(QMouseEvent* const event,
MeshData& mesh_data, QGLViewer* viewer) {
// Delegate roations etc. to default behaviour, if we are not in edit mode.
if (!doubleclick_is_edit_event(event)) {
qDebug() << "Using default mouse behavior.";
return false;
}
qDebug() << "Using edit mode mouse behavior.";
// Save previous modification
if (edit_in_progress_) {
qDebug() << "Saving previous modifications to a mesh point";
qreal x, y, z;
manipulated_frame_.getPosition(x, y, z);
if (!isnan(x) && !isnan(y) && !isnan(z)) {
Point& p = *edited_point_;
p[0] = x;
p[1] = y;
p[2] = z;
qDebug("New Position: %f %f %f", p[0], p[1], p[2]);
qDebug() << "Saving modified mesh";
mesh_data.load_and_duplicate(std::move(editable_mesh_), mesh_id_);
// Remove frame as the edit operation is completed.
viewer->setManipulatedFrame(nullptr);
edit_in_progress_ = false;
}
} else {
qDebug() << "Handling a new click on a mesh point";
click_x_ = event->x();
click_y_ = event->y();
unhandled_click_ = true;
// During the next redraw we will handle the click
}
return true;
}
