// generate 12 triangles: 36 vertices and 36 colors
void Tetrahedron::draw()
{
drawTriangles(2, 0, 1);//front face
drawTriangles(2, 3, 0);//left face
drawTriangles(2, 3, 1);//right face
drawTriangles(1, 3, 0);//bottom face
}
void MyGL::drawTriangles(BVHnode* meshNode, int depth) {
if ((depth % 5) == 0) {
prog_flat.setModelMatrix(meshNode->boundingBox->transformation);
prog_flat.draw(*this, *meshNode->boundingBox);
}
//recurse and draw children's boxes
if(meshNode->leftChild != NULL) {
drawTriangles(meshNode->leftChild, depth+1);
}
if (meshNode->rightChild != NULL) {
drawTriangles(meshNode->rightChild, depth+1);
}
}
void GLWidget::paintGL()
{
glClearColor(1.0, 1.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
switch (type)
{
case 0: drawPoints() ;
break;
case 1: drawLines();
break;
case 2: drawLineStrip();
break;
case 3: drawLineLoop();
break;
case 4: drawTriangles();
break;
case 5: drawTriangleStrip();
break;
case 6: drawTriangleFan();
break;
case 7: drawQuads();
break;
case 8: drawQuadStrip();
break;
case 9: drawPolygons();
break;
default: break;
}
}
void Mesh::draw(Colour col, int x)
{
glPushMatrix();
glTranslatef(mPos.x, mPos.y, mPos.z);
glRotatef(mRot.x, 1, 0, 0);
glRotatef(mRot.y, 0, 1, 0);
glRotatef(mRot.z, 0, 0, 1);
if (x & VOXELS) drawVoxels(Colour(0,0xFF,0));
if (x & SOLID) drawTriangles(col, false);
if (x & WIRE) drawTriangles(Colour(0,0,0), true);
if (x & NORMALS) drawNormals(col);
if (x & AABB) drawAABB(Colour(0xA5, 0x2A, 0x2A), x&HIER);
if (x & SPHERE) drawSphere(Colour(0xA5, 0x2A, 0x2A), x&HIER);
if (x & TBOXES) drawTriangleBoxes(Colour(0xFF,0,0));
glPopMatrix();
}
Mat& FaceTracker::draw(Mat& img){
if(failed)
return img;
drawTriangles(img);
drawLines(img);
drawPoints(img);
return img;
}
Mat& FaceTracker::draw(){
if(grayImg.empty()||failed)
return grayImg;
drawTriangles(grayImg);
drawLines(grayImg);
drawPoints(grayImg);
return grayImg;
}
void ARectangle::drawFramed(float x1, float y1, float x2, float y2, float lwidth,
const Point4D& color, const Point4D &framecolor)
{
setParams(x1, y1, x2, y2, color);
drawTriangles (vboIds[1]);
_scaleX = _scaleX * (x2-x1) / (x2-x1 + lwidth/view->width);
_scaleY= _scaleY * (y2-y1) / (y2-y1 + lwidth/view->height);
drawLines(GL_LINE_LOOP,vboIds[2], nvertices, framecolor , lwidth);
}
void Octahedron::draw()
{
drawTriangles(0, 1, 2);//left face
drawTriangles(2, 3, 0);//right face
drawTriangles(0, 3, 4);//back right face
drawTriangles(4, 1, 0);//back left face
drawTriangles(1, 5, 2);//bottom front left face
drawTriangles(2, 5, 3);//bottom front right face
drawTriangles(3, 5, 4);//bottom back right face
drawTriangles(4, 5, 1);//bottom back left face
}
void TriangView::paintGL() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glScalef(scale, scale, scale);
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
glRotatef(zRot, 0.0f, 0.0f, 1.0f);
drawTriangles();
}
///////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
GLfloat x = 0.0f;
GLfloat y = 0.0f;
GLfloat z = 0.0f;
GLfloat angle = 0.0f;
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawTriangles();
// drawSpheres();
// Flush drawing commands
glutSwapBuffers();
}
/**
* @brief drawBVHnodes
* @brief Helper function that draws BVHnodes
*/
void MyGL::drawBoxes(BVHnode* node) {
if (node->geom != NULL && node->geom->isMesh()) {
drawTriangles(((Mesh*)node->geom)->MeshRootBVHnode, 0);
}
prog_flat.setModelMatrix(node->boundingBox->transformation);
prog_flat.draw(*this, *node->boundingBox);
//recurse and draw children's boxes
if(node->leftChild != NULL) {
drawBoxes(node->leftChild);
}
if (node->rightChild != NULL) {
drawBoxes(node->rightChild);
}
}
// generate 12 triangles: 36 vertices and 36 colors
void BoxShape::draw()
{
if(!isWall)
{
drawTriangles( 1, 0, 3, 2 );
drawTriangles( 2, 3, 7, 6 );
drawTriangles( 3, 0, 4, 7 );
drawTriangles( 6, 5, 1, 2 );
drawTriangles( 4, 5, 6, 7 );
drawTriangles( 5, 4, 0, 1 );
}
}
void switchShape(int shape){
switch ( shape )
{
case 0:
drawTriangles();
break;
case 1:
drawSquares();
break;
case 2:
drawStar();
break;
default:
break;
}
}
// Generate the Graphics
void displayFcn(void)
{
// Clear display window.
glClear(GL_COLOR_BUFFER_BIT);
// Draw 3 different rectangles
drawRectangles();
// Draw triangles
drawTriangles();
// Draw house
drawHouse();
// Draw square
drawSquare();
// Execute
glFlush();
}
void DirectionalLight::draw( OpenGLPtr openGL, const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix, const glm::vec4* contourColor ) const
{
openGL->setShadingMode( ShadingMode::SOLID_PLAIN );
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
// Send this "mesh" and the MVP matrix to the shader.
Mesh::sendToShader( *openGL, viewMatrix, projectionMatrix );
for( const auto& trianglesGroup : trianglesGroups_ ){
// Send this mesh's material to shader.
//materials_[polygonsGroup.materialIndex]->sendToShader();
glDrawElements( GL_TRIANGLES,
trianglesGroup.nTriangles * 3,
GL_UNSIGNED_INT,
( std::intptr_t* )( trianglesGroup.firstTriangleIndex * 3 * sizeof( GL_UNSIGNED_INT ) ) );
}
// Set the color for the mesh's contour.
// TODO: Use only one condition (force contourColor to be passed as a
// reference?)
if( displaysEdges() && ( contourColor != nullptr ) ){
openGL->setShadingMode( ShadingMode::SOLID_PLAIN );
sendColorToShader( *contourColor );
// Now we'll draw mesh's contour. Set polygon mode for rendering
// lines.
// TODO: I still have to use polygon offset.
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
// Draw Mesh's contour
drawTriangles();
// Return polygon mode to previos GL_FILL.
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
}
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
}
void RenderTwentatenta()
{
float ico_vertices[3 * 12] = {
0., 0., -0.9510565162951536,
0., 0., 0.9510565162951536,
-0.85065080835204, 0., -0.42532540417601994,
0.85065080835204, 0., 0.42532540417601994,
0.6881909602355868, -0.5, -0.42532540417601994,
0.6881909602355868, 0.5, -0.42532540417601994,
-0.6881909602355868, -0.5, 0.42532540417601994,
-0.6881909602355868, 0.5, 0.42532540417601994,
-0.2628655560595668, -0.8090169943749475, -0.42532540417601994,
-0.2628655560595668, 0.8090169943749475, -0.42532540417601994,
0.2628655560595668, -0.8090169943749475, 0.42532540417601994,
0.2628655560595668, 0.8090169943749475, 0.42532540417601994 };
int ico_faces[3*20] = {
1 , 11 , 7 ,
1 , 7 , 6 ,
1 , 6 , 10 ,
1 , 10 , 3 ,
1 , 3 , 11 ,
4 , 8 , 0 ,
5 , 4 , 0 ,
9 , 5 , 0 ,
2 , 9 , 0 ,
8 , 2 , 0 ,
11 , 9 , 7 ,
7 , 2 , 6 ,
6 , 8 , 10 ,
10 , 4 , 3 ,
3 , 5 , 11 ,
4 , 10 , 8 ,
5 , 3 , 4 ,
9 , 11 , 5 ,
2 , 7 , 9 ,
8 , 6 , 2 };
drawTriangles(20, ico_vertices, ico_faces);
}
void SystemMesh::draw( OpenGLPtr openGL, const glm::mat4 &viewMatrix, const glm::mat4 &projectionMatrix, const glm::vec4 *contourColor ) const
{
openGL->setShadingMode( ShadingMode::SOLID_LIGHTING );
sendToShader( *openGL, viewMatrix, projectionMatrix );
sendMaterialToShader( 0 );
for( const TrianglesGroupWithTextureWall& trianglesGroup : trianglesGroups_ ){
if( textureWallsManager_->textureWallIncludesTexture( trianglesGroup.textureWallID ) ){
openGL->setShadingMode( ShadingMode::SOLID_LIGHTING_AND_TEXTURING );
textureWallsManager_->sendTextureWallToShader( trianglesGroup.textureWallID );
}else{
openGL->setShadingMode( ShadingMode::SOLID_LIGHTING );
}
drawTriangles( trianglesGroup.firstTriangleIndex, trianglesGroup.nTriangles );
}
drawEdges( openGL, viewMatrix, projectionMatrix, contourColor );
if( displaysVertexNormals() ){
drawVertexNormals( openGL, viewMatrix, projectionMatrix, glm::vec4( 1.0f, 0.0f, 0.0f, 0.0f ) );
}
}
void drawer_t::drawLists( void )
{
if ( ! head )
return;
tessellation_t * tes = head;
do
{
switch ( tes->type )
{
case DT_QUADS:
drawQuads( tes );
break;
case DT_TRIANGLES:
drawTriangles( tes );
break;
}
tes = tes->next;
}
while ( tes );
}
void ARectangle::draw(float x1, float y1, float x2, float y2, const Point4D &color)
{
setParams(x1, y1, x2, y2, color);
// _color.alpha = 0.3;
drawTriangles (vboIds[1]);
}
void RenderScene(void) {
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
//glFrontFace(GL_CW);
glUseProgram(shader);
float angle=timer.GetElapsedSeconds()*M_PI/5;
M3DVector3f at={1,0,0};
M3DVector3f up={0,0,1};
M3DVector3f eye;
eye[0]=6.0f*cos(angle);
eye[1]=6.0f*sin(angle);
eye[2]=kz;
LookAt(cameraFrame,eye,at,up);
geometryPipeline.SetMatrixStacks(modelView,projection);
//swiatlo
M3DVector3f ambientLight = {1.0f, 1.0f, 1.0f};
M3DVector3f position = {2.0f, 2.0f, 5.0f};
M3DVector3f color = {1.0f, 1.0f, 1.0f};
float l_angle = 90.0f;
float attenuation0 = 0.5f;
float attenuation1 = 0.02f;
float attenuation2 = 0.05f;
M3DVector3f ambientColor = {0.1f, 0.1, 0.1};
M3DVector3f diffuseColor = {0.184f, 0.598f, 0.75f};
M3DVector3f specularColor = {1.0f, 1.0f, 1.0f};
float specularExponent = 9;
float ico_vertices[3 * 12] = {
0., 0., -0.9510565162951536,
0., 0., 0.9510565162951536,
-0.85065080835204, 0., -0.42532540417601994,
0.85065080835204, 0., 0.42532540417601994,
0.6881909602355868, -0.5, -0.42532540417601994,
0.6881909602355868, 0.5, -0.42532540417601994,
-0.6881909602355868, -0.5, 0.42532540417601994,
-0.6881909602355868, 0.5, 0.42532540417601994,
-0.2628655560595668, -0.8090169943749475, -0.42532540417601994,
-0.2628655560595668, 0.8090169943749475, -0.42532540417601994,
0.2628655560595668, -0.8090169943749475, 0.42532540417601994,
0.2628655560595668, 0.8090169943749475, 0.42532540417601994};
int ico_faces[3*20] = {
1 , 11 , 7 ,
1 , 7 , 6 ,
1 , 6 , 10 ,
1 , 10 , 3 ,
1 , 3 , 11 ,
4 , 8 , 0 ,
5 , 4 , 0 ,
9 , 5 , 0 ,
2 , 9 , 0 ,
8 , 2 , 0 ,
11 , 9 , 7 ,
7 , 2 , 6 ,
6 , 8 , 10 ,
10 , 4 , 3 ,
3 , 5 , 11 ,
4 , 10 , 8 ,
5 , 3 , 4 ,
9 , 11 , 5 ,
2 , 7 , 9 ,
8 , 6 , 2 };
projection.LoadMatrix(viewFrustum.GetProjectionMatrix());
cameraFrame.GetCameraMatrix(mCamera);
modelView.LoadMatrix(mCamera);
modelView.PushMatrix();
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(normalMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniform3fv(shaderPositionLocation, 1, position);
glUniform3fv(shaderColorLocation, 1, color);
glUniform1f(shaderAngleLocation, l_angle);
glUniform1f(shaderAttenuation0Location, attenuation0);
glUniform1f(shaderAttenuation1Location, attenuation1);
glUniform1f(shaderAttenuation2Location, attenuation2);
glUniform3fv(shaderAmbientColorLocation, 1, ambientColor);
glUniform3fv(shaderDiffuseColorLocation, 1, diffuseColor);
glUniform3fv(shaderSpecularColorLocation, 1, specularColor);
glUniform1f(shaderSpecularExponentLocation, specularExponent);
glPolygonOffset(1.0f, 1.0f);
drawGrid();
glEnable(GL_POLYGON_OFFSET_FILL);
drawGrid();
glDisable(GL_POLYGON_OFFSET_FILL);
modelView.Translate(-2.0f,-2.0f,2.0f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(normalMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniform3fv(shaderPositionLocation, 1, position);
glUniform3fv(shaderColorLocation, 1, color);
glUniform1f(shaderAngleLocation, l_angle);
glUniform1f(shaderAttenuation0Location, attenuation0);
glUniform1f(shaderAttenuation1Location, attenuation1);
glUniform1f(shaderAttenuation2Location, attenuation2);
glUniform3fv(shaderAmbientColorLocation, 1, ambientColor);
glUniform3fv(shaderDiffuseColorLocation, 1, diffuseColor);
glUniform3fv(shaderSpecularColorLocation, 1, specularColor);
glUniform1f(shaderSpecularExponentLocation, specularExponent);
drawTriangles(20, ico_vertices, ico_faces);
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(2.0,2.0,2.0);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(normalMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniform3fv(shaderPositionLocation, 1, position);
glUniform3fv(shaderColorLocation, 1, color);
glUniform1f(shaderAngleLocation, l_angle);
glUniform1f(shaderAttenuation0Location, attenuation0);
glUniform1f(shaderAttenuation1Location, attenuation1);
glUniform1f(shaderAttenuation2Location, attenuation2);
glUniform3fv(shaderAmbientColorLocation, 1, ambientColor);
glUniform3fv(shaderDiffuseColorLocation, 1, diffuseColor);
glUniform3fv(shaderSpecularColorLocation, 1, specularColor);
glUniform1f(shaderSpecularExponentLocation, specularExponent);
drawSmoothTriangles(20, ico_vertices, ico_faces);
modelView.PopMatrix();
glutSwapBuffers();
glutPostRedisplay();
}
void ExploreLiveView::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget * widget)
{
if(!isReady) return;
prePaint(painter);
postPaint(painter);
auto glwidget = (Viewer*)widget;
if (glwidget && meshes.size())
{
QRectF parentRect = parentItem()->sceneBoundingRect();
if (isCacheImage && cachedImage.isNull())
{
QOpenGLContext context;
context.setShareContext(glwidget->context());
context.setFormat(glwidget->format());
context.create();
QOffscreenSurface m_offscreenSurface;
m_offscreenSurface.setFormat(context.format());
m_offscreenSurface.create();
context.makeCurrent(&m_offscreenSurface);
QOpenGLFramebufferObjectFormat fboformat;
fboformat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
QOpenGLFramebufferObject renderFbo(cacheImageSize*1.5, cacheImageSize, fboformat);
renderFbo.bind();
glwidget->glEnable(GL_DEPTH_TEST);
glwidget->glEnable(GL_BLEND);
glwidget->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glwidget->glCullFace(GL_BACK);
glwidget->glClearColor(0,0,0,0);
glwidget->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glwidget->glViewport(0, 0, cacheImageSize*1.5, cacheImageSize);
// XXX Fix
// glwidget->glPointSize(10);
// Draw aux meshes
for (auto mesh : meshes)
{
if (mesh.isPoints)
glwidget->drawOrientedPoints(mesh.points, mesh.normals, mesh.color, glwidget->pvm);
else
glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, glwidget->pvm);
}
glwidget->glDisable(GL_DEPTH_TEST);
glwidget->glFlush();
renderFbo.release();
cachedImage = renderFbo.toImage();
isReady = true;
// Thanks for sharing!
glwidget->makeCurrent();
}
// Draw as image
if(isCacheImage)
{
int w = shapeRect.width();
painter->drawImage(w * -0.5, w * -0.5, cachedImage.scaledToWidth(w));
}
if(!isCacheImage)
{
auto r = shapeRect;
// scale view
double s = 1.5;
r.setWidth(r.width() * s);
r.setHeight(r.height() * s);
r.moveCenter(this->mapToScene(boundingRect().center()));
painter->beginNativePainting();
auto v = scene()->views().first();
QPoint viewDelta = v->mapFromScene(r.topLeft());
if (viewDelta.manhattanLength() > 5) r.moveTopLeft(viewDelta);
auto camera = ExploreProcess::defaultCamera(document->extent().length());
glwidget->eyePos = camera.first;
glwidget->pvm = camera.second;
glwidget->glViewport(r.left(), v->height() - r.height() - r.top(), r.width(), r.height());
// Clipping OpenGL
glwidget->glEnable(GL_SCISSOR_TEST);
glwidget->glScissor(parentRect.x(), v->height() - parentRect.height() - parentRect.top(), parentRect.width(), parentRect.height());
glwidget->glClear(GL_DEPTH_BUFFER_BIT);
// FIX XXX
// glwidget->glPointSize(2);
// Draw aux meshes
for (auto mesh : meshes)
{
if (mesh.isPoints)
glwidget->drawOrientedPoints(mesh.points, mesh.normals, mesh.color, glwidget->pvm);
else
glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, glwidget->pvm);
}
glwidget->glDisable(GL_SCISSOR_TEST);
painter->endNativePainting();
}
}
}
void RenderScene(void) {
load_vertices("geode_vertices.dat", vertices);
load_faces("geode_faces.dat", faces);
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(float), &vertices[0], GL_STATIC_DRAW);
glVertexAttribPointer(GLT_ATTRIBUTE_VERTEX, 4 ,GL_FLOAT,GL_FALSE, sizeof(float) * 7, (const GLvoid *)0);
glVertexAttribPointer(GLT_ATTRIBUTE_NORMAL, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 7, (const GLvoid *)(4*sizeof(float)) );
glEnableVertexAttribArray(GLT_ATTRIBUTE_VERTEX);
glEnableVertexAttribArray(GLT_ATTRIBUTE_NORMAL);
//---
glGenBuffers(1, &faces_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, faces_buffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces.size() * sizeof(GLuint), &faces[0], GL_STATIC_DRAW);
//---
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// Obracanie widoku
float angle =timer.GetElapsedSeconds()*PI/4;
posVector[0] = -8.0f * cos(angle / 2.0f);
posVector[1] = -8.0f * sin(angle / 2.0f);
posVector[2] = 5.0f;
swiatlo0.position[0] = 8.0f * cos(-angle);
swiatlo0.position[1] = 15.0f * sin(-angle);
swiatlo0.position[2] = 5.0f;
LookAt(viewFrame, posVector, atVector, upVector);
geometryPipeline.SetMatrixStacks(modelView,projection);
projection.LoadMatrix(viewFrustum.GetProjectionMatrix());
modelView.PushMatrix();
M3DMatrix44f mCamera;
viewFrame.GetCameraMatrix(mCamera);
modelView.LoadMatrix(mCamera);
modelView.PushMatrix();
//glUseProgram(shader);
modelView.Translate(swiatlo0.position[0], swiatlo0.position[1], swiatlo0.position[2]);
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
modelView.PopMatrix();
//mno¿enie macierzy
//modelView.MultMatrix(mCamera);
// modelView.PushMatrix();
//m3dMatrixMultiply44(mModelViewProjection, viewFrustum.GetProjectionMatrix(), mCamera);
// wrzucanie do shadera
glUniformMatrix3fv(NMatrixLocation, 1, GL_FALSE, geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(VMmatrixLocation, 1, GL_FALSE, mCamera);
glUniform3fv(iambient_component_location, 1, iambient_component);
glUniform3fv(swiatlo0_location, 1, swiatlo0.position);
glUniform3fv(swiatlo0_idiffuse_location, 1, swiatlo0.idiffuse);
glUniform3fv(swiatlo0_ispecular_location, 1, swiatlo0.ispecular);
glUniform3fv(swiatlo0_attenuation_location, 1, swiatlo0.attenuation);
glUniform1f(material0_ka_location, material0.ka);
glUniform1f(material0_kd_location, material0.kd);
glUniform1f(material0_ks_location, material0.ks);
glUniform1f(material0_alpha_location, material0.alpha);
//--
glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewMatrix());
//DrawPramid(0.5,0.0,1.0);
drawTriangles(20,ico_vertices,ico_faces);
// rysowanie siatki --------------------------------------------------------------------------
glEnable(GL_CULL_FACE);
glPolygonOffset(1.0f, 1.0f);
glVertexAttrib3f(GLT_ATTRIBUTE_COLOR, 1.0, 1.0, 1.0);
glEnable(GL_POLYGON_OFFSET_FILL);
glBegin(GL_QUADS);
glVertex3f(10, -10.0f, 0.0f);
glVertex3f(-10, -10.0f, 0.0f);
glVertex3f(-10, 10.0f, 0.0f);
glVertex3f(10, 10.0f, 0.0f);
glEnd();
glDisable(GL_POLYGON_OFFSET_FILL);
glVertexAttrib3f(GLT_ATTRIBUTE_COLOR, 1.0, 1.0, 1.0);
for(int i=-10;i<=10;i++){
glBegin(GL_LINES);
glVertex3f((float)i, -10.0f, 0.0f);
glVertex3f((float)i, 10.0f, 0.0f);
glEnd();
}
for(int i=-10;i<=10;i++){
glBegin(GL_LINES);
glVertex3f(-10.0f, (float)i, 0.0f);
glVertex3f(10.0f, (float)i, 0.0f);
glEnd();
}
glDisable(GL_CULL_FACE);
//sphereBatch.Draw();
glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewMatrix());
modelView.PopMatrix();
// rysowanie siatki - koniec -------------------------------------------------------------------
//matrixStack.Translate(10.0f,1.0f,0.0f);
// macierz translacji i macierz rotacji
//M3DMatrix44f mT,mR;
// m3dTranslationMatrix44(mT,0.0f,3.0f,0.0f);
//m3dRotationMatrix44(mR, angle, 0.0f, 0.0f, 1.0f);
//mno¿enie macierzy translacji i macierzy rotacji
//m3dMatrixMultiply44(mM,mT,mR);
//mno¿enie macierzy przekszta³ceñ i macierzy projekcji modelwidok
// m3dMatrixMultiply44(mModelViewProjection,mModelViewProjection, mM);
//wysy³anie macierzy projekcji modelwidok do shadera
//glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, mModelViewProjection);
//TriangleFace(position,color,atVector);
//DrawPramid(0.5,0.0,1.0);
//drawTriangles(20, ico_vertices, ico_faces);
//matrixStack.PopMatrix();
//matrixStack.Rotate(45.0,0,0,1);
//matrixStack.Translate(0.0,0.0,1.0);
//glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
//DrawPramid(0.5,0.0,1.0);
glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(MVMatrixLocation, 1, GL_FALSE, geometryPipeline.GetModelViewMatrix());
modelView.PopMatrix();
glUseProgram(Pshader);//wywo³anie shadera
// Perform the buffer swap to display back buffer
glutSwapBuffers();
glutPostRedisplay();
}
Mat& FaceTracker::drawTriangles(Mat& img){
return drawTriangles(img, CV_RGB(0,0,0));
}
void Thumbnail::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *widget)
{
QRectF parentRect = parentItem()->sceneBoundingRect();
// Skip drawing thumbnails outside their parents
if (!sceneBoundingRect().intersects(parentRect)) return;
prePaint(painter, widget);
// Draw image
if(!img.isNull())
{
auto imgRect = QRectF(img.rect());
imgRect.moveCenter(rect.center());
painter->drawImage(imgRect.topLeft(), img);
}
// Draw 3D mesh
if(mesh.points.size() || auxMeshes.size())
{
if (img.isNull() || isTempImage)
{
auto glwidget = (Viewer*)widget;
if (glwidget)
{
QOpenGLContext context;
context.setShareContext(glwidget->context());
context.setFormat(glwidget->format());
context.create();
QOffscreenSurface m_offscreenSurface;
m_offscreenSurface.setFormat(context.format());
m_offscreenSurface.create();
context.makeCurrent(&m_offscreenSurface);
QOpenGLFramebufferObjectFormat fboformat;
fboformat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
QOpenGLFramebufferObject renderFbo(rect.width() * 2, rect.height() * 2, fboformat);
renderFbo.bind();
glwidget->glEnable(GL_DEPTH_TEST);
glwidget->glEnable(GL_BLEND);
glwidget->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glwidget->glCullFace(GL_BACK);
glwidget->glClearColor(0,0,0,0);
glwidget->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glwidget->glViewport(0, 0, renderFbo.size().width(), renderFbo.size().height());
if(mesh.points.size())
glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, pvm);
// Draw aux meshes
for (auto auxmesh : auxMeshes)
glwidget->drawTriangles(auxmesh.color, auxmesh.points, auxmesh.normals, pvm);
glwidget->glDisable(GL_DEPTH_TEST);
glwidget->glFlush();
renderFbo.release();
this->setImage( renderFbo.toImage().scaledToWidth(rect.width(), Qt::SmoothTransformation) );
// Thanks for sharing!
glwidget->makeCurrent();
}
/*painter->beginNativePainting();
auto glwidget = (Viewer*)widget;
if (glwidget)
{
// Draw mesh
auto r = sceneBoundingRect();
auto v = scene()->views().first();
QPoint viewDelta = v->mapFromScene(r.topLeft());
if (viewDelta.manhattanLength() > 5) r.moveTopLeft(viewDelta);
glwidget->eyePos = eye;
glwidget->pvm = pvm;
glwidget->glViewport(r.left(), v->height() - r.height() - r.top(), r.width(), r.height());
// Clipping OpenGL
glwidget->glEnable(GL_SCISSOR_TEST);
glwidget->glScissor(parentRect.x(), v->height() - parentRect.height() - parentRect.top(), parentRect.width(), parentRect.height());
glwidget->glClear(GL_DEPTH_BUFFER_BIT);
glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, pvm);
// Draw aux meshes
for (auto auxmesh : auxMeshes)
{
glwidget->drawTriangles(auxmesh.color, auxmesh.points, auxmesh.normals, pvm);
}
glwidget->glDisable(GL_SCISSOR_TEST);
}
painter->endNativePainting();*/
}
}
// Draw the caption
if(caption.size())
{
painter->setPen(QPen(Qt::white,1));
auto textRect = rect;
textRect.setHeight(painter->fontMetrics().height() * 1.25);
textRect.moveBottom(rect.height() - textRect.height() * 0.5);
painter->drawText(textRect, caption, Qt::AlignVCenter | Qt::AlignHCenter);
}
postPaint(painter, widget);
}
void RenderScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glUniform3fv(shaderMaterialAmbientLocation, 1, ambientColor);
glUniform3fv(shaderMaterialDiffuseLocation, 1, diffuseColor);
glUniform3fv(shaderMaterialSpecularLocation, 1, specularColor);
glUniform1f(shaderMaterialSpecularExponentLocation, specularExponent);
glUniform3fv(shaderPositionLocation, 1, position);
glUniform3fv(shaderColorLocation, 1, color);
glUniform1f(shaderAngleLocation, angle);
glUniform1f(shaderAttenuation0Location, attenuation0);
glUniform1f(shaderAttenuation1Location, attenuation1);
glUniform1f(shaderAttenuation2Location, attenuation2);
GLMatrixStack modelView;
GLMatrixStack projection;
GLGeometryTransform geometryPipeline;
geometryPipeline.SetMatrixStacks(modelView,projection);
projection.LoadMatrix(frustum.GetProjectionMatrix());
modelView.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelView.LoadMatrix(mCamera);
modelView.PushMatrix();
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
rysujSiatke();
modelView.PushMatrix();
modelView.Translate(0.0f,0.0f,-1.f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
rysujTrojkat();
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(0.0f,4.0f,0.f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
rysujTrojkat();
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(3.0f,-3.0f,0.f);
modelView.Scale(2.0f,2.0f,2.f);
modelView.Rotate(45,0,0,1);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
rysujTrojkat();
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(3.0f,3.0f,0.f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
drawTriangles(20, ico_vertices,ico_faces);
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(0.0f,0.0f,7.f);
modelView.Rotate(90+rotAngle,1,1,1);
modelView.Scale(2.0f,2.5f,2.5f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
drawTriangles(20, ico_vertices,ico_faces);
modelView.PopMatrix();
modelView.PushMatrix();
modelView.Translate(-4.0f,0.0f,4.f);
modelView.Scale(2.0f,2.0f,2.0f);
glUniformMatrix4fv(MVMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewMatrix());
glUniformMatrix3fv(MNMatrixLocation,1,GL_FALSE,geometryPipeline.GetNormalMatrix());
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,geometryPipeline.GetModelViewProjectionMatrix());
glDrawElements(GL_TRIANGLES,3*n_faces,GL_UNSIGNED_INT,0);
modelView.PopMatrix();
// Perform the buffer swap to display back buffer
glutSwapBuffers();
rotAngle+=5.f;
if(!stopRotate){
M3DVector3f at={0,0,0};
M3DVector3f up={0,0,1};
M3DVector3f eye;
float angle = timer.GetElapsedSeconds()*3.14159f /3.f;
eye[0]=16.f*cos(angle);
eye[1]=40.0f*sin(angle);
eye[2]=20.0f;
LookAt(cameraFrame,eye,at,up);
}
glutPostRedisplay();
}
BAGamesCommand BAGame::showCharSelect(){
BACharacterData availableCharacters[4];
// make char data
// name, spriteID, #OfShots per round, small ships, medium ships, large ships, difficulty
availableCharacters[0] = BACharacterDataMake("Matt", CharacterIDMatt, 1, 3, 2, 1, CharDifficultyEasy);
availableCharacters[1] = BACharacterDataMake("Mimi", CharacterIDMimi, 1, 5, 2, 1, CharDifficultyHard);
availableCharacters[2] = BACharacterDataMake("Kenji", CharacterIDKenji, 1, 2, 2, 2, CharDifficultyHard);
availableCharacters[3] = BACharacterDataMake("Naru", CharacterIDNaru, 2, 2, 2, 0, CharDifficultyHard);
// helper
byte selectedCharIndex = 0;
byte bgAnimator = 0;
byte selectionAnimator = 0;
// Screenloop
while(true){
if (!arduboy.nextFrame()) continue;
// update input
globalInput.updateInput();
// check input
if(globalInput.pressed(RIGHT_BUTTON)){
selectedCharIndex = (selectedCharIndex+1)%4;
}
if(globalInput.pressed(LEFT_BUTTON)){
selectedCharIndex = (selectedCharIndex-1)%4;
}
if(globalInput.pressed(UP_BUTTON)){
selectedCharIndex = (selectedCharIndex-2)%4;
}
if(globalInput.pressed(DOWN_BUTTON)){
selectedCharIndex = (selectedCharIndex+2)%4;
}
if(globalInput.pressed(A_BUTTON)){
playSoundBack();
return BAGamesCommandBack;
}
if(globalInput.pressed(B_BUTTON)){
player = new BAPlayer(availableCharacters[selectedCharIndex]);
// get random enemy but not itself
byte enemyCharIndex = random(4);
while(enemyCharIndex == selectedCharIndex) enemyCharIndex = random(4);
enemyPlayer = new BAPlayer(availableCharacters[enemyCharIndex]);
return BAGamesCommandNext;
}
if (arduboy.everyXFrames(3)){
bgAnimator++;
bgAnimator = bgAnimator%3;
}
if (arduboy.everyXFrames(15)){
selectionAnimator++;
selectionAnimator = selectionAnimator%2;
}
ABPoint offset;
offset.x = ( ((selectedCharIndex%2) == 0)?0:64);
offset.y = ( (selectedCharIndex > 1)?32:0);
// clear screen
arduboy.clear();
// draw stuff
drawSelection(offset, selectionAnimator);
drawTriangles(offset, bgAnimator);
// draw chars
for(size_t i = 0; i < 4; i++){
ABPoint charOffset;
charOffset.x = 64 * (i%2);
charOffset.y = ((i>1)?32:0);
drawCharacterSelectionAsset(availableCharacters[i], charOffset);
}
arduboy.display();
}
return BAGamesCommandErr;
}
