std::shared_ptr<SimpleMesh> SimpleMeshCreator::rectangle(vec3 posLl, vec3 posUr) {
auto rec = std::make_shared<SimpleMesh>();
// Set identity matrix
rec->setModelMatrix(mat4(1.f));
vec3 texCoordLl(0, 0, 0);
vec3 texCoordUr(1, 1, 0);
vec4 colorLl(1, 1, 1, 1);
vec4 colorUr(0, 1, 0, 1);
// 4 corners
rec->addVertex(posLl, texCoordLl, colorLl);
rec->addVertex(vec3(posLl.x, posUr.y, posLl.z), vec3(texCoordLl.x, texCoordUr.y, texCoordLl.z),
vec4(colorLl.x, colorUr.y, colorLl.z, colorLl.w));
rec->addVertex(vec3(posUr.x, posLl.y, posUr.z), vec3(texCoordLl.x, texCoordUr.y, texCoordUr.z),
vec4(colorLl.x, colorUr.y, colorUr.z, colorLl.w));
rec->addVertex(posUr, texCoordUr, colorUr);
// 4 indices (?)
rec->setIndicesInfo(DrawType::Triangles, ConnectivityType::Strip);
rec->addIndex(1);
rec->addIndex(3);
rec->addIndex(0);
rec->addIndex(2);
return rec;
}
void recursive_render(const aiNode* nd)
{
// Get node transformation matrix
aiMatrix4x4 m = nd->mTransformation;
// OpenGL matrices are column major
m.Transpose();
// save model matrix and apply node transformation
pushMatrix();
float aux[16];
memcpy(aux,&m,sizeof(float) * 16);
MathHelp::multMatrix(modelMatrix, aux);
setModelMatrix();
// draw all meshes assigned to this node
for (unsigned int n=0; n < nd->mNumMeshes; ++n)
{
// bind material uniform
glBindBufferRange(GL_UNIFORM_BUFFER, materialUniLoc, myMeshes[nd->mMeshes[n]].uniformBlockIndex, 0, sizeof(struct Helper::MyMaterial));
// bind texture
glBindTexture(GL_TEXTURE_2D, myMeshes[nd->mMeshes[n]].texIndex);
// bind VAO
glBindVertexArray(myMeshes[nd->mMeshes[n]].vao);
// draw
glDrawElements(GL_TRIANGLES,myMeshes[nd->mMeshes[n]].numFaces*3,GL_UNSIGNED_INT,0);
}
// draw all children
for (unsigned int n=0; n < nd->mNumChildren; ++n)
{
recursive_render(nd->mChildren[n]);
}
popMatrix();
}
void CitySceneGenerator::generate(Scene* scene) {
auto renderer = scene->renderer();
auto material = std::make_shared<PhongMaterial>(renderer);
material->setShader(renderer->shaderManager()->getGlslProgram("phong"));
PhongMaterialData materialData = { glm::vec4(0.0f, 0.1f, 0.0f, 1.0f),
glm::vec4(0.8f, 0.3f, 0.1f, 1.0f), glm::vec4(0.3f, 0.3f, 0.3f, 1.0f), 5.0f };
material->properties()->setData(materialData);
material->properties()->flushData();
auto mesh = std::make_shared<Mesh>();
mesh->setPrimitiveType(PrimitiveType::TriangleList);
size_t buildingVerticesCount = sizeof(buildingVertices) / sizeof(*buildingVertices);
std::vector<char> vertices(reinterpret_cast<const char*>(buildingVertices),
reinterpret_cast<const char*>(buildingVertices) + sizeof(buildingVertices));
std::vector<VertexElement> layout = {
VertexElement(3, VertexElementType::Float),
VertexElement(3, VertexElementType::Float)
};
mesh->loadVertices(vertices, buildingVerticesCount, layout);
size_t buildingIndicesCount = sizeof(buildingIndices) / sizeof(*buildingIndices);
std::vector<uint32_t> indices(reinterpret_cast<const unsigned*>(buildingIndices),
reinterpret_cast<const unsigned*>(buildingIndices) + buildingIndicesCount);
mesh->loadIndices(indices);
size_t numBuildings = 1000;
float citySize = 500.0f;
float minBuildingSize = 10.0f;
float maxBuildingSize = 60.0f;
float minHeightToWidthRatio = 8.0f;
float maxHeightToWidthRatio = 16.0f;
std::uniform_real_distribution<float> angleDist(0.0f, 360.0f);
std::uniform_real_distribution<float> positionDist(-citySize, citySize);
std::uniform_real_distribution<float> canonicalDist;
std::vector<std::shared_ptr<BaseSceneObject>> buildings;
for (size_t i = 0; i < numBuildings; i++) {
auto building = std::make_shared<Building>(mesh, material);
// set random position
glm::mat4 model = glm::translate(glm::mat4(1.0f),
glm::vec3(positionDist(m_rng), positionDist(m_rng), 0.0f)
);
// rotate around z with random angle
model = glm::rotate(model, angleDist(m_rng), glm::vec3(0.0f, 0.0f, 1.0f));
glm::vec3 scale;
// multiplying uniform distribution will generate beta distribution
scale.x = canonicalDist(m_rng) * canonicalDist(m_rng) * canonicalDist(m_rng) * canonicalDist(m_rng)
* (maxBuildingSize - minBuildingSize) + minBuildingSize;
scale.y = scale.x;
scale.z = canonicalDist(m_rng) * canonicalDist(m_rng) * canonicalDist(m_rng) * scale.x
* (maxHeightToWidthRatio - minHeightToWidthRatio) + minHeightToWidthRatio;
model = glm::scale(model, scale);
building->setModelMatrix(model);
building->calculateBBox();
buildings.push_back(building);
}
scene->setStaticGeometry(std::move(buildings));
}
Track::Track(GLint givenVertexBufferLoc,
GLint givenNormalBufferLoc) {
setLoader(new ObjLoader());
ObjLoader * myLoaderRef = getLoader();
myLoaderRef -> loadObj(TRACK_PATH, MTL_BASEPATH);
// In this OpenGL program, x-z is the horizontal plane.
// The following code snippet grabs the x and z coordinates of all the
// vertices that are at the bottom of the inner walls of the track.
//std::cout << "ListPlot[ { " << std::endl;
std::vector<GLfloat> vertices = myLoaderRef->getVertices();
for (int i = 0; i < vertices.size(); i += 3) {
if (vertices[i + 1] > 1) continue;
//if (i) std::cout << ", ";
//std::cout << "{" << vertices[i] << ", " << vertices[i + 2] << "}";
walls.push_back(glm::vec2(vertices[i], vertices[i+2]));
}
//std::cout << " } ]" << std::endl;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
myLoaderRef -> getVertices().size() * sizeof(GLfloat),
myLoaderRef -> getVertices().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &normalBuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
glBufferData(GL_ARRAY_BUFFER,
myLoaderRef -> getNormals().size() * sizeof(GLfloat),
myLoaderRef -> getNormals().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
myLoaderRef -> getIndices().size() * sizeof(GLuint),
myLoaderRef -> getIndices().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
vertexCount = (unsigned int) myLoaderRef -> getIndices().size();
// setup initial model matrix
scaleMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -1.0f, 0.0f)) * glm::mat4(1.0f);
setModelMatrix(scaleMatrix);
// wrap states using vao
glGenVertexArraysAPPLE(1, &vertexArrayObjectHandle);
glBindVertexArrayAPPLE(vertexArrayObjectHandle);
// bind vertex array
glEnableVertexAttribArray(givenVertexBufferLoc);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexAttribPointer(givenVertexBufferLoc,
3, // to simplify program, we always use triangles
GL_FLOAT, // type of elements in vertex buffer is GLfloat
GL_FALSE, // not normalized
0, // to simplify program, we keep each object in a homogeneous buffer
0);
glEnableVertexAttribArray(givenNormalBufferLoc);
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
glVertexAttribPointer(givenNormalBufferLoc,
3,
GL_FLOAT,
GL_FALSE,
0,
0);
// bind index array
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
// finished: unbind vao to clear state
glBindVertexArrayAPPLE(0);
}
void GLWidget::paintGL() //Renderschleife
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Buffer bereinigen (vor Neuzeichnung)
setProjektionsMatrix();
glBindTexture(GL_TEXTURE_2D,texid[0]); //Textur 0
glFrustum( -1.6f, 1.6f, -1.2f, 1.2f, 1.5f, 6.5f ); // 3D View (Clipping-Planes)
glTranslatef(transx,transy,transz); //Verschiebung - Translation
glRotatef(rotWinkel,rotx,roty,rotz);
glScalef(skalx,skaly,skalz);
setModelMatrix();
glBegin( GL_QUADS ); //Würfel aus 6 Quadraten
glColor3f(1.0f, 1.0f, 1.0f ); // damit Originalfarbe angezeigt wird 1/1/1
glTexCoord2f(0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glColor3f(1.0f, 1.0f, 1.0f );
glTexCoord2f(0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f( 1.0f, -1.0f, 1.0f);
glColor3f(1.0f, 1.0f, 1.0f );
glTexCoord2f(0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f( 1.0f, -1.0f, -1.0f);
glColor3f(1.0f, 1.0f, 1.0f );
glTexCoord2f(0.0f,0.0f);
glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glColor3f(1.0f, 1.0f, 1.0f );
glTexCoord2f(0.0f,0.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glColor3f(1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f,1.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(1.0f,1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(1.0f,0.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glEnd();
if(Animation)
{
rotWinkel++;
}
setProjektionsMatrix();
glFrustum( -1.6f, 1.6f, -1.2f, 1.2f, 1.5f, 6.5f );
glTranslatef(0.0f,0.0f,-3.5f);
glRotatef(60.0f,1.0f,1.0f,0.0f);
setModelMatrix();
DrawAchsen();
}
void MandelbrotDrawable::setPosition(const glm::vec3& pos)
{
M_[3] = glm::vec4(pos, 1.0f);
setModelMatrix(glm::value_ptr(M_));
}
std::shared_ptr<Volume> curlVolume(std::shared_ptr<const Volume> volume) {
auto newVolume = std::make_shared<Volume>(volume->getDimensions(), DataVec3Float32::get());
newVolume->setModelMatrix(volume->getModelMatrix());
newVolume->setWorldMatrix(volume->getWorldMatrix());
newVolume->dataMap_ = volume->dataMap_;
auto m = newVolume->getCoordinateTransformer().getDataToWorldMatrix();
auto a = m * vec4(0, 0, 0, 1);
auto b = m * vec4(1.0f / vec3(volume->getDimensions() - size3_t(1)), 1);
auto spacing = b - a;
vec3 ox = vec3(spacing.x, 0, 0);
vec3 oy = vec3(0, spacing.y, 0);
vec3 oz = vec3(0, 0, spacing.z);
VolumeDoubleSampler<4> sampler(volume);
auto worldSpace = VolumeDoubleSampler<3>::Space::World;
util::IndexMapper3D index(volume->getDimensions());
auto data = static_cast<vec3*>(newVolume->getEditableRepresentation<VolumeRAM>()->getData());
float minV = std::numeric_limits<float>::max(), maxV = std::numeric_limits<float>::lowest();
std::function<void(const size3_t&)> func = [&](const size3_t& pos) {
vec3 world = (m * vec4(vec3(pos) / vec3(volume->getDimensions() - size3_t(1)), 1)).xyz();
auto Fx =
(sampler.sample(world + ox, worldSpace) - sampler.sample(world - ox, worldSpace)) /
(2.0 * spacing.x);
auto Fy =
(sampler.sample(world + oy, worldSpace) - sampler.sample(world - oy, worldSpace)) /
(2.0 * spacing.y);
auto Fz =
(sampler.sample(world + oz, worldSpace) - sampler.sample(world - oz, worldSpace)) /
(2.0 * spacing.z);
vec3 c;
c.x = static_cast<float>(Fy.z - Fz.y);
c.y = static_cast<float>(Fz.x - Fx.z);
c.z = static_cast<float>(Fx.y - Fy.x);
minV = std::min(minV, c.x);
minV = std::min(minV, c.y);
minV = std::min(minV, c.z);
maxV = std::max(maxV, c.x);
maxV = std::max(maxV, c.y);
maxV = std::max(maxV, c.z);
data[index(pos)] = c;
};
util::forEachVoxel(*volume->getRepresentation<VolumeRAM>(), func);
auto range = std::max(std::abs(minV), std::abs(maxV));
newVolume->dataMap_.dataRange = dvec2(-range, range);
newVolume->dataMap_.valueRange = dvec2(minV, maxV);
return newVolume;
}
void CRender::orthoUnset(void) {
setProjectionMatrix();
popMatrix();
setModelMatrix();
}
