void EndPatchRenderer::prerenderSetup(int level, std::function<void (const glm::vec4 &)> setDrawColor)
{
assert(indexBufferGenerated);
assert(ibo != std::numeric_limits<GLuint>::max());
assert(vboRef == controlMesh->vbo);
setDrawColor(glm::vec4(0.f, 1.f, 1.f, 1.f)); // Debug
glUseProgram(program);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, controlMesh->vbo);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ovbo);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, nibo);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 9, uvBuffer);
if (controlMesh->hasTexture)
{
glBindTextureUnit(4, controlMesh->diffuseMap);
}
if (controlMesh->hasDisplacementMap)
{
glBindTextureUnit(5, controlMesh->displacementMap);
}
glPatchParameteri(GL_PATCH_VERTICES, 3);
}
void GSceneManager::drawScene(GSceneNode* sn_p_drawNode, SceneTyp sct_typ, GLuint& glui_shaderProgram)
{
// Vertexliste zeichnen
// Für alle Knoten zeichnen
bindUniformModelMatrix(sn_p_drawNode, glui_shaderProgram);
for (GLuint glui_meshIter = 0; glui_meshIter < (sn_p_drawNode->returnNumOfMesh()); glui_meshIter++)
{
// Texture anbinden (GL_TEXTURE_0) und an Shader übergeben
if (sct_typ == INTERACT || sct_typ == DYNAMIC)
bindUniformTextureMaterial (sn_p_drawNode->returnMesh(glui_meshIter)->returnRMaterial(), glui_shaderProgram);
// EZR: Umgebungstexturen anbinden
else if (sct_typ == WORLD || sct_typ == SKYBOX)
bindUniformEnvironmentTextureMaterial(sct_typ, glui_shaderProgram);
glBindVertexArray( sn_p_drawNode->returnMeshVA(glui_meshIter) );
if (sct_typ == INTERACT)
{
bindUniformCameraPosition(glui_shaderProgram);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawElements(GL_PATCHES, sn_p_drawNode->returnNumOfMeshFaces(glui_meshIter)*3, GL_UNSIGNED_INT, 0);
}
else
glDrawElements(GL_TRIANGLES, sn_p_drawNode->returnNumOfMeshFaces(glui_meshIter)*3 , GL_UNSIGNED_INT, 0);
}
//Rekursiv alle Kinderknoten aufrufen und zeichnen
for (unsigned int ui_numNode = 0; ui_numNode < sn_p_drawNode->returnChildrenVector().size(); ui_numNode++)
{
drawScene(sn_p_drawNode->returnChildrenVector()[ui_numNode], sct_typ, glui_shaderProgram);
}
}
void TesselationApp::draw() {
int maxTess = 30;
float tessStartDistance = 8;
float scale = maxTess - (camera->position.length() - tessStartDistance);
std::stringstream tess;
tess << "Tess " << int(scale);
// fontOverlay->updateText("tess",tess.str());
std::stringstream dist;
dist << "Dist " << camera->position.length();
// fontOverlay->updateText("dist",dist.str());
if (scale > 1){
shader->use();
shader->setUniform("TessLevelInner",scale);
shader->setUniform("TessLevelOuter",scale);
}
OpenGL::Instance().clear();
glEnable(GL_DEPTH_TEST);
// glEnable(GL_CULL_FACE);
groundNode->setView(camera);
glError;
#ifdef USE_OPENGL4
glPatchParameteri(GL_PATCH_VERTICES, 3);
groundNode->draw();
#endif
glError;
}
bool Init()
{
Vector3f Pos(0.0f, 1.5f, -6.5f);
Vector3f Target(0.0f, -0.2f, 1.0f);
Vector3f Up(0.0, 1.0f, 0.0f);
m_pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT, Pos, Target, Up);
if (!m_lightingEffect.Init()) {
printf("Error initializing the lighting technique\n");
return false;
}
GLint MaxPatchVertices = 0;
glGetIntegerv(GL_MAX_PATCH_VERTICES, &MaxPatchVertices);
printf("Max supported patch vertices %d\n", MaxPatchVertices);
glPatchParameteri(GL_PATCH_VERTICES, 3);
m_lightingEffect.Enable();
m_lightingEffect.SetColorTextureUnit(COLOR_TEXTURE_UNIT_INDEX);
m_lightingEffect.SetDirectionalLight(m_directionalLight);
m_pMesh = new Mesh();
return m_pMesh->LoadMesh("../Content/monkey.obj");
}
void display()
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindVertexArray(VertexArrayName);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1);
glf::checkError("display");
glf::swapBuffers();
}
static void render_ob(t_env const *e, t_ob *ob)
{
t_model const *const mo = MOOFOB(e, ob);
t_mesh const *const me = MEOFMO(e, mo);
t_program const *const p = POFME(e, me);
if (mo->update_uniforms != NULL)
NORM_AT_42_IS_WTF(e, ob, mo);
if (mo->texture != sp_no_texture)
sp_activate_texture(p, sp_image1_texslot, TOFMO(e, mo), "ourTexture");
if (p->gltexi[sp_sbox_texslot] >= 0)
sp_activate_texture(p, sp_sbox_texslot, &e->sbox_texture, "depthMap");
if (me->program == sp_landrender_program)
{
sp_activate_texture(p, sp_image1_texslot, &e->land_tex1, "ymap");
sp_activate_texture(p, sp_image2_texslot, &e->land_tex2, "colmap");
sp_activate_texture(p, sp_image3_texslot, &e->land_tex3, "normap");
}
glBindVertexArray(me->handles[0]);
if (p->tcshader != sp_no_tcshader)
{
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawElements(GL_PATCHES, me->faces3, GL_UNSIGNED_INT, 0);
}
else
glDrawElements(GL_TRIANGLES, me->faces3, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
return ;
}
void
VSTerrainLODSingleScaledLib::render() {
glPatchParameteri( GL_PATCH_VERTICES, 1 );
mVSML->pushMatrix(VSMathLib::MODEL);
mVSML->multMatrix(VSMathLib::MODEL, mMesh.transform);
mVSML->matricesToGL();
VSShaderLib::setBlock(mMaterialBlockName, &(mMesh.mat));
// bind textures
for (int t = 0; t < VSShaderLib::MAX_TEXTURES; t++) {
if (mMesh.texUnits[t] != 0) {
glActiveTexture(GL_TEXTURE0 + t);
glBindTexture(GL_TEXTURE_2D, mMesh.texUnits[t]);
}
}
// bind VAO
glBindVertexArray(mMesh.vao);
glDrawArrays(mMesh.type,0,mMesh.numIndices);
for (int t = 0; t < VSShaderLib::MAX_TEXTURES; t++) {
if (mMesh.texUnits[t] != 0) {
glActiveTexture(GL_TEXTURE0 + t);
glBindTexture(GL_TEXTURE_2D, 0);
}
}
glBindVertexArray(0);
mVSML->popMatrix(VSMathLib::MODEL);
}
void PartialPatchSharpRenderer::prerenderSetup(int level, std::function<void(const glm::vec4 &)> setDrawColor)
{
setDrawColor(glm::vec4(1.f, 0.f, 0.f, 1.f)); // Debug
glPolygonMode(GL_FRONT_AND_BACK, g_shadingMode);
glPatchParameteri(GL_PATCH_VERTICES, 16);
}
void display()
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Compute the MVP (Model View Projection matrix)
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
// Set the display viewport
glViewport(0, 0, Window.Size.x, Window.Size.y);
// Clear color buffer with black
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
// Bind program
glUseProgram(ProgramName);
// Set the value of MVP uniform.
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
// Bind vertex array & draw
glBindVertexArray(VertexArrayName);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1);
glf::checkError("display");
glf::swapBuffers();
}
void SCE_RUseProgram (SCE_RProgram *prog)
{
if (prog) {
glUseProgram (prog->id);
/* useless 'if' statements in a full GL3 renderer */
if (prog->use_vmap)
SCE_RUseVertexAttributesMap (prog->map);
else
SCE_RDisableVertexAttributesMap ();
if (prog->use_mmap) {
sce_rmatindex = prog->mat_map;
SCE_RMapMatrices (prog->funs);
} else {
/* useless in a full GL3 renderer */
SCE_RMapMatrices (NULL);
}
if (prog->use_tess) {
glPatchParameteri (GL_PATCH_VERTICES, prog->patch_vertices);
/* tell the renderer to use GL_PATCHES as primitive type */
SCE_RUsePatches ();
} else
SCE_RUsePrimitives ();
} else {
SCE_RUsePrimitives ();
glUseProgram (0);
/* useless calls in a full GL3 renderer */
SCE_RDisableVertexAttributesMap ();
SCE_RMapMatrices (NULL);
}
}
void SoftBody::RenderPatches()
{
glPatchParameteri(GL_PATCH_VERTICES, 3);
glBindVertexArray(vao);
glDrawElements(GL_PATCHES, indices.size(), GL_UNSIGNED_INT, (void *)0);
glBindVertexArray(0);
}
void Mesh::render()
{
int vertexAttributeCount = m_vertexAttributes.size();
for (int i = 0; i < vertexAttributeCount; i++)
{
m_vertexAttributes[i].applyState();
}
// Index buffer
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
if (m_glPrimitiveType == GL_PATCHES)
{
glPatchParameteri(GL_PATCH_VERTICES, m_patchVertCount);
}
if (m_instanceCount > 1)
{
glDrawElementsInstanced(m_glPrimitiveType, m_indexCount, GL_UNSIGNED_INT,
(void*)0, // element array buffer offset
m_instanceCount
);
}
else
{
glDrawElements(m_glPrimitiveType, m_indexCount, GL_UNSIGNED_INT,
(void*)0 // element array buffer offset
);
}
for (int i = 0; i < vertexAttributeCount; i++)
{
m_vertexAttributes[i].unapplyState();
}
}
void PezRender(GLuint fbo)
{
glUniform1f(Uniforms.TessLevel, TessLevel);
glUniform1f(Uniforms.TessLevelOuter, TessLevelOuter);
glUniform1f(Uniforms.NormalModel, NormalModel);
glUniform1f(Uniforms.Tesselation, Tesselation);
glUniform1f(Uniforms.Wireframe, Wireframe);
glUniform1f(Uniforms.Tagg, Tagg);
glUniform1f(Uniforms.ColNorm, ColNorm);
glUniform1f(Uniforms.DCol, DCol);
Vector4 lightPosition = V4MakeFromElems(0.25, 0.25, 1, 0);
glUniform3fv(Uniforms.LightPosition, 1, &lightPosition.x);
glUniformMatrix4fv(Uniforms.Projection, 1, 0, &ProjectionMatrix.col0.x);
glUniformMatrix4fv(Uniforms.Modelview, 1, 0, &ModelviewMatrix.col0.x);
Matrix3 nm = M3Transpose(NormalMatrix);
float packed[9] = { nm.col0.x, nm.col1.x, nm.col2.x,
nm.col0.y, nm.col1.y, nm.col2.y,
nm.col0.z, nm.col1.z, nm.col2.z };
glUniformMatrix3fv(Uniforms.NormalMatrix, 1, 0, &packed[0]);
// Render the scene:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glUniform3f(Uniforms.AmbientMaterial, 0.04f, 0.04f, 0.04f);
glUniform3f(Uniforms.DiffuseMaterial, 0, 0.75, 0.75);
glDrawElements(GL_PATCHES, IndexCount, GL_UNSIGNED_INT, 0);
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindVertexArray(VertexArrayName);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
assert(!validate(ProgramName[program::VERT]));
glDrawArraysInstancedBaseInstance(GL_PATCHES, 0, VertexCount, 1, 0);
return true;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x * 0.5f / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y));
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBufferName);
glViewport(0, 0, static_cast<GLsizei>(WindowSize.x * 0.5f), static_cast<GLsizei>(WindowSize.y));
glUseProgram(ProgramName[0]);
glUniformMatrix4fv(UniformMVP[0], 1, GL_FALSE, &MVP[0][0]);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1);
glViewport(static_cast<GLint>(WindowSize.x * 0.5f), 0, static_cast<GLsizei>(WindowSize.x * 0.5f), static_cast<GLsizei>(WindowSize.y));
glUseProgram(ProgramName[1]);
glUniformMatrix4fv(UniformMVP[1], 1, GL_FALSE, &MVP[0][0]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
return true;
}
void CurveCurvature::SetScene() {
Example::zNear = 0.1f;
Example::zFar = 20.0;
Example::camStep = 0.1f;
this->kDisplacement = 1.0; //Velocidad de movimiento
Example::camPos = glm::vec3(1.5, 1.5, 2);
Example::camCenter = glm::vec3(1.5, 1.5, 0);
Example::camUp = glm::vec3(0, 1, 0);
Example::camEyeTarget = glm::normalize(Example::camCenter - Example::camPos);
this->RecalcMatrices();
this->tessellate = true;
this->maxTess = 32.0;
this->tessDefault = 32.0;
this->hasMouseExtended = false;
this->selectedPoint = 0;
this->numLines = 2.0;
this->curvFactor = 10.0;
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
glPatchParameteri(GL_PATCH_VERTICES, this->VERTICES_PER_PATCH);
}
bool render()
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
*Pointer = Projection * this->view() * glm::mat4(1.0f);
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
assert(!validate(ProgramName[program::VERT]));
glDrawArraysInstancedBaseInstance(GL_PATCHES, 0, VertexCount, 1, 0);
return true;
}
void display()
{
glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x / 2) / float(Window.Size.y), 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glViewport(0, 0, Window.Size.x, Window.Size.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBufferName);
glViewport(0, 0, Window.Size.x / 2, Window.Size.y);
glUseProgram(ProgramName[0]);
glUniformMatrix4fv(UniformMVP[0], 1, GL_FALSE, &MVP[0][0]);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1);
glViewport(Window.Size.x / 2, 0, Window.Size.x / 2, Window.Size.y);
glUseProgram(ProgramName[1]);
glUniformMatrix4fv(UniformMVP[1], 1, GL_FALSE, &MVP[0][0]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
glf::checkError("display");
glf::swapBuffers();
}
Renderer::Renderer(const Desc & desc)
: RendererHelper<1>("PerlinNoiseOceanRenderer", "PerlinNoiseOceanWireFrameRenderer", Renderer::ERenderPass::Deferred_Pass)
, mHeightMapCS(nullptr)
, mCubeMapTexture(Engine::GetInstance()->GetTextureManager()->LoadTextureCubeMap(desc.mSkyboxCubeMapTextureFilename))
, mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->LoadTexture2D("medias/textures/OceanColor256.tif", GL_REPEAT, GL_REPEAT))
//, mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->GetDefaultTexture2D())
, mHeightMapTextureSize(desc.mHeightMapTextureSize)
, mMapSize(desc.mMapWidth, desc.mMapDepth)
, mPatchCount(desc.mMapWidth / 64, desc.mMapDepth / 64)
, mMapCount(0)
, mDrawNormalShader("TerrainDrawNormals")
{
PRINT_BEGIN_SECTION;
PRINT_MESSAGE("Initialize PerlinNoiseOceanRenderer.....");
const glm::vec3 vertices[] =
{
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 0.0f, 1.0f),
glm::vec3(1.0f, 0.0f, 1.0f)
};
//setup vao and vbo stuff
CreateBuffers();
glBindVertexArray(mVaoID);
glBindBuffer(GL_ARRAY_BUFFER, mVboIDs[VertexArrayBufferIndex]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GL_CHECK_ERRORS;
glEnableVertexAttribArray(Shader::POSITION_ATTRIBUTE);
glVertexAttribPointer(Shader::POSITION_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);
GL_CHECK_ERRORS;
glPatchParameteri(GL_PATCH_VERTICES, 4);
glBindVertexArray(0);
GL_CHECK_ERRORS;
mMapCount = (GLint)desc.mMaps.size();
PerMapData * modelMatrixBuffer = new PerMapData[mMapCount];
for (int i = 0; i < mMapCount; ++i)
{
modelMatrixBuffer[i].mModelDQ = desc.mMaps[i].mModelDQ;
}
mModelMatrixBuffer.CreateResource(GL_STATIC_DRAW, GL_RGBA32F, (mMapCount * sizeof(PerMapData)), modelMatrixBuffer);
LoadShaders(desc);
mIsInitialized = true;
PRINT_MESSAGE(".....PerlinNoiseOceanRenderer initialized!");
PRINT_END_SECTION;
}
void objMesh::drawTesselation()
{
glBindVertexArray(vao);
glBindTexture(GL_TEXTURE_2D, textureIndex);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawArrays(GL_PATCHES, 0, nVertices);
glBindVertexArray(0);
}
void Demo05::Initialize() {
shaderManager.CreateShaderProgram("Shader");
shaderManager.AttachShader("ShaderVertex" , VERTEX);
shaderManager.AttachShader("ShaderTessCont", TESS_CNTRL);
shaderManager.AttachShader("ShaderTessEval", TESS_EVAL);
shaderManager.AttachShader("ShaderGeometry", GEOMETRY);
shaderManager.AttachShader("ShaderFragment", FRAGMENT);
shaderManager.LoadShaderSource("ShaderVertex" , "data/shaders/demo05/tessellation.vert.glsl");
shaderManager.LoadShaderSource("ShaderTessCont", "data/shaders/demo05/tessellation.cont.glsl");
shaderManager.LoadShaderSource("ShaderTessEval", "data/shaders/demo05/tessellation.eval.glsl");
shaderManager.LoadShaderSource("ShaderGeometry", "data/shaders/demo05/tessellation.geom.glsl");
shaderManager.LoadShaderSource("ShaderFragment", "data/shaders/demo05/tessellation.frag.glsl");
shaderManager.CompileShader("ShaderVertex");
shaderManager.CompileShader("ShaderTessCont");
shaderManager.CompileShader("ShaderTessEval");
shaderManager.CompileShader("ShaderGeometry");
shaderManager.CompileShader("ShaderFragment");
shaderManager.AttachShaderToProgram("Shader", "ShaderVertex");
shaderManager.AttachShaderToProgram("Shader", "ShaderTessCont");
shaderManager.AttachShaderToProgram("Shader", "ShaderTessEval");
shaderManager.AttachShaderToProgram("Shader", "ShaderGeometry");
shaderManager.AttachShaderToProgram("Shader", "ShaderFragment");
shaderManager.BindAttribute("Shader", 0, "a_vertex");
shaderManager.LinkProgramObject("Shader");
shaderManager["Shader"]->Activate();
std::auto_ptr<ObjModel> model(new ObjModel);
model->Load("data/model/obj/bunny.obj");
triangleCount = model->faces.size();
GLsizei vertexCount = model->vertices.size();
glGenBuffers(2, &vboID[0]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboID[0]); // elements
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*3*triangleCount, &*model->faces.begin(), GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, vboID[1]); // vertices
glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint)*3*vertexCount, &*model->vertices.begin(), GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenVertexArrays(1, &vaoID[0]);
glBindVertexArray(vaoID[0]);
glBindBuffer(GL_ARRAY_BUFFER, vboID[1]);
shaderManager["Shader"]->VertexAttribPointer("a_vertex", 3, GL_FLOAT, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
shaderManager["Shader"]->EnableAttribArray("a_vertex");
glBindVertexArray(0);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// We work with 4 points per patch.
glPatchParameteri(GL_PATCH_VERTICES, 3);
}
void Reyes::RendererGLWire::prepare()
{
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPatchParameteri(GL_PATCH_VERTICES, 4);
}
void Patch::draw(const Program &program) {
bindTessLevel(program);
// TODO should be called once
glPatchParameteri(GL_PATCH_VERTICES, vertexCountPerPatch);
//this->drawingMode = GL_PATCHES;
Mesh::draw(program);
}
void TerrainRenderer::paint()
{
dp::sg::renderer::rix::gl::SceneRendererSharedPtr renderer = getSceneRenderer().staticCast<dp::sg::renderer::rix::gl::SceneRenderer>();
if ( !m_renderEngine.empty() && renderer->getRenderEngine() != m_renderEngine )
{
std::cout << "Setting renderengine: " << m_renderEngine << std::endl;
renderer->setRenderEngine( m_renderEngine );
}
renderer->setShaderManager( m_shaderManager);
glPatchParameteri( GL_PATCH_VERTICES, 1 ); // TODO temporary, terrain patch has only 1 'virtual' vertex per patch
//glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
dp::util::FrameProfiler::instance().beginFrame();
if ( m_benchmarkFrames != ~0 || m_duration != 0.0 )
{
if ( m_renderedFrames == 1 )
{
m_benchmarkTimer.start();
m_benchmarkProgressTimer.start();
}
SceneRendererWidget::paint();
if ( m_benchmarkProgressTimer.getTime() > 1.0 )
{
m_benchmarkProgressTimer.restart();
std::ostringstream os;
os << "Benchmark Progress: ";
if ( m_benchmarkFrames != ~0 )
{
os << m_renderedFrames << "/" << m_benchmarkFrames;
}
else
{
os << std::setprecision(2) << m_benchmarkTimer.getTime() << "/" << m_duration;
}
setWindowTitle( os.str() );
}
if ( (m_benchmarkFrames != ~0 && m_renderedFrames == m_benchmarkFrames) || (m_duration > 0.0 && m_benchmarkTimer.getTime() > m_duration) )
{
m_benchmarkTimer.stop();
m_exitCode = int(double(m_renderedFrames) / m_benchmarkTimer.getTime());
glutLeaveMainLoop();
}
// at the end since the first frame does not count
++m_renderedFrames;
}
else
{
SceneRendererWidget::paint();
}
dp::util::FrameProfiler::instance().endFrame();
}
void xprGpuDrawPatch(size_t offset, size_t count, size_t vertexPerPatch, size_t flags)
{
#if !defined(XPR_GLES_2)
GLenum mode = GL_PATCHES;
if(nullptr != glPatchParameteri) {
glPatchParameteri(GL_PATCH_VERTICES, vertexPerPatch);
glDrawArrays(mode, offset, count);
}
#endif
}
/**
****************************************************************************************************
@brief Draws object by calling it's display list. Before this object is transformed and rotated to
it's current position. Then attached material is rendered(TMaterial::RenderMaterial())
There are specific types of settings, when object is not rendered (e.g. when rendering into shadow map
is active and object don't cast shadows)
@param tessellate draw object with HW tessellation enabled?
****************************************************************************************************/
void TObject::Draw(bool tessellate)
{
//don't draw object with draw_object flag set to false
if(!m_draw_object)
return;
#ifdef VERBOSE
cout<<"Drawing "<<m_name << endl;
#endif
if(m_type != INSTANCE)
glBindVertexArray(m_vbo.vao);
//set patch parameter
int patch = m_drawmode;
if(tessellate)
{
if(m_drawmode == GL_TRIANGLE_STRIP)
glPatchParameteri(GL_PATCH_VERTICES, 4);
else
glPatchParameteri(GL_PATCH_VERTICES, 3);
patch = GL_PATCHES;
}
//different drawing mode: simple vertex array or array with element indices
if(m_element_indices)
{
//it's possible to use geometry instancing (if there is more than 1 object instance)
if(m_instances > 1)
glDrawElementsInstanced(patch, m_vbo.indices, GL_UNSIGNED_INT , 0, m_instances);
else
glDrawElements(patch, m_vbo.indices, GL_UNSIGNED_INT , 0);
}
else
{
if(m_instances > 1)
glDrawArraysInstanced(patch, 0, m_vbo.indices * 3, m_instances);
else
glDrawArrays(patch, 0, m_vbo.indices * 3);
}
#ifdef VERBOSE
cout<<"...done\n";
#endif
}
void PipelineImpl::setTessellationState(GlState& state) const
{
if(!m_tessellation || state.m_stateHashes.m_tessellation == m_hashes.m_tessellation)
{
return;
}
state.m_stateHashes.m_tessellation = m_hashes.m_tessellation;
glPatchParameteri(GL_PATCH_VERTICES, m_in.m_tessellation.m_patchControlPointCount);
}
void xprGpuDrawPatchIndexed(size_t offset, size_t count, size_t minIdx, size_t maxIdx, size_t vertexPerPatch, size_t flags)
{
#if !defined(XPR_GLES_2)
GLenum mode = GL_PATCHES;
GLenum indexType = xprGL_INDEX_TYPE[flags & 0x000F];
if(nullptr != glPatchParameteri) {
glPatchParameteri(GL_PATCH_VERTICES, vertexPerPatch);
glDrawRangeElements(mode, minIdx, maxIdx, count, indexType, (void*)offset);
}
#endif
}
void drawExplosion(double time){
GLuint loc;
glUseProgram(explosion_shader);
loc = glGetUniformLocation(explosion_shader, "time");
glUniform1f(loc, time);
glBindVertexArray(explosion_vao);
glPatchParameteri(GL_PATCH_VERTICES, 1);
glDrawArrays(GL_POINTS, 0, MAX_EXPLOSION / 3);
}
void Terrain::render(Shader *shader) {
computeModelMatrix();
glUniformMatrix4fv(shader->loc_model_matrix, 1, false, glm::value_ptr(Model));
glUniform1ui(shader->loc_displacement_factor, displacement_factor);
glBindVertexArray(VAO);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawElements(GL_PATCHES, n_indices, GL_UNSIGNED_INT, NULL);
glBindVertexArray(0);
}
