/** * Create the STL encoder factory singleton and define the default options. */ STLEncoderFactory* STLEncoderFactory::createInstance() { prtx::EncoderInfoBuilder encoderInfoBuilder; encoderInfoBuilder.setID(STLEncoder::ID); encoderInfoBuilder.setName(STLEncoder::NAME); encoderInfoBuilder.setDescription(STLEncoder::DESCRIPTION); encoderInfoBuilder.setType(prt::CT_GEOMETRY); encoderInfoBuilder.setExtension(STL_EXT); // optionally we could setup a validator // encoderInfoBuilder.setValidator(prtx::EncodeOptionsValidatorPtr(new MyOptionsValidator())); prtx::PRTUtils::AttributeMapBuilderPtr amb(prt::AttributeMapBuilder::create()); amb->setString(EO_BASE_NAME, L"stl_default_name"); // required by CityEngine amb->setBool(EO_ERROR_FALLBACK, prtx::PRTX_TRUE); // required by CityEngine encoderInfoBuilder.setDefaultOptions(amb->createAttributeMap()); // CityEngine requires the following annotations to create an UI for an option: // label, order, group and description prtx::EncodeOptionsAnnotator eoa(encoderInfoBuilder); eoa.option(EO_BASE_NAME) .setLabel(L"Base Name") .setOrder(0.0) .setGroup(L"General Settings", 0.0) .setDescription(L"Sets the base name of the written STL file."); // Hide the error fallback option in the CityEngine UI. eoa.option(EO_ERROR_FALLBACK).flagAsHidden(); return new STLEncoderFactory(encoderInfoBuilder.create()); }
void Loader::LoadMaterial(const aiScene *pScene, const char *file_name) { //store material for(int i = 0 ;i<pScene->mNumMaterials;i++) { aiColor3D dif(0.f,0.f,0.f); aiColor3D amb(0.f,0.f,0.f); aiColor3D spec(0.f,0.f,0.f); aiMaterial * the_material = pScene->mMaterials[i]; CMC_Material * material = new CMC_Material(); the_material->Get(AI_MATKEY_COLOR_AMBIENT,amb); the_material->Get(AI_MATKEY_COLOR_DIFFUSE,dif); the_material->Get(AI_MATKEY_COLOR_SPECULAR,spec); material->ambientColor = QVector3D(amb.r,amb.g,amb.b); material->diffuseColor = QVector3D(dif.r,dif.g,dif.b); material->specularColor = QVector3D(spec.r,spec.g,spec.b); aiString normalPath; the_material->GetTexture (aiTextureType_NORMALS,0,&normalPath); //now ,we only use the first diffuse texture, will fix it later aiString diffuse_Path; the_material->GetTexture(aiTextureType_DIFFUSE,0,&diffuse_Path); if(diffuse_Path.length == 0 ) { material->diffuseTexturePath = "INVALID"; }else { material->diffuseTexturePath = diffuse_Path.C_Str (); } m_model->addMaterial (material); } }
bool CD3DGraphics11::RenderBumpMapShdaer(D3DXMATRIX world, int numIndices, CMaterialDX11 mat) { CGameScene& scene = SYSTEM::PROJECT::GetScene(); CGameobjectList l = scene.GetLightList(); int n_l = l.GetNumObjects(); CCamera* c = scene.GetCamera(0); if (!c) return false; D3DXVECTOR4 amb(mat.GetAmbientColor().r, mat.GetAmbientColor().g, mat.GetAmbientColor().b, mat.GetAmbientColor().a); D3DXVECTOR4 spec(mat.GetSpecularColor().r, mat.GetSpecularColor().g, mat.GetSpecularColor().b, mat.GetSpecularColor().a); D3DXVECTOR3 camPos(c->GetTransform().GetTranslation().x, c->GetTransform().GetTranslation().y, c->GetTransform().GetTranslation().z); ID3D11ShaderResourceView* difTex = mat.GetDiffuseTexture(); ID3D11ShaderResourceView* specTex = mat.GetSpecularMap(); ID3D11ShaderResourceView* bumpTex = mat.GetBumpMap(); if (!difTex) difTex = m_pDefaultTexture; if (!specTex) specTex = m_pDefaultTexture; if (!bumpTex) bumpTex = m_pDefaultTexture; return m_bumpMapShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, difTex, specTex, bumpTex, l, n_l,amb, camPos, spec, 64.0f); return true; }
int main() { namespace fusion = boost::fusion; typedef fusion::vector<int, int, int> value_type; std::vector<value_type> vec; AMB_BLOCK(ctx) { amber& x = amb(ctx, 0, amb1_f); amber& y = amb(ctx, 1, amb2_f); amber& z = amb(ctx, 2, amb3_f); vec.push_back(value_type(x.get(), y.get(), z.get())); }; const std::vector<value_type> expected = boost::assign::list_of<value_type> (1, 4, 6) (1, 4, 7) (1, 4, 8) (1, 5, 6) (1, 5, 7) (1, 5, 8) (2, 4, 6) (2, 4, 7) (2, 4, 8) (2, 5, 6) (2, 5, 7) (2, 5, 8) (3, 4, 6) (3, 4, 7) (3, 4, 8) (3, 5, 6) (3, 5, 7) (3, 5, 8) ; BOOST_TEST(boost::equal(vec, expected)); return boost::report_errors(); }
int _main() { const char *w1,*w2,*w3,*w4; w1 = amb(3, "the", "that", "a"); w2 = amb(3, "frog", "elephant", "thing"); w3 = amb(3, "walked", "treaded", "grows"); w4 = amb(2, "slowly", "quickly"); if(!joins(w1, w2)) amb(0); if(!joins(w2, w3)) amb(0); if(!joins(w3, w4)) amb(0); printf("%s %s %s %s\n", w1, w2, w3, w4); return EXIT_SUCCESS; }
void projA(std::complex<double> A[d3][d3], std::complex<double> U[d3][d3]) { // A = proj(U), where U is projected on a antihermitian traceless matrix A // proj(U) = ( U - U^dag)/2 - i*( U - U^dag)/2 )/3 std::complex<double> Udag[d3][d3], UmUdag[d3][d3]; aeb(Udag,U); adag(Udag); amb(UmUdag, U,Udag); za(UmUdag, 0.5, UmUdag); aeb(A,UmUdag); std::complex<double> trace; trace = UmUdag[0][0] + UmUdag[1][1] + UmUdag[2][2]; for (int i=0; i<d3; i++) { A[i][i] -= trace/(double)3; } }
bool CD3DGraphics11::RenderTextureLightingShader(D3DXMATRIX world, int numIndices, CMaterialDX11 mat) { CGameScene& scene = SYSTEM::PROJECT::GetScene(); CGameobjectList l = scene.GetLightList(); int n_l = l.GetNumObjects(); CCamera* c = scene.GetCamera(0); if(!c) return false; D3DXVECTOR4 amb(mat.GetAmbientColor().r,mat.GetAmbientColor().g,mat.GetAmbientColor().b,mat.GetAmbientColor().a); D3DXVECTOR4 spec(mat.GetSpecularColor().r,mat.GetSpecularColor().g,mat.GetSpecularColor().b,mat.GetSpecularColor().a); D3DXVECTOR3 camPos(c->GetTransform().GetTranslation().x,c->GetTransform().GetTranslation().y, c->GetTransform().GetTranslation().z); if (mat.GetDiffuseTexture()) return m_textureLightingShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, mat.GetDiffuseTexture(), l, n_l, amb, camPos, spec, 64.0f); else return m_textureLightingShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, m_pDefaultTexture, l, n_l, amb, camPos, spec, 64.0f); return true; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); ui->tab_2->setEnabled(false); ui->pushButton_3->setEnabled(false); ui->btnSmooth->setEnabled(false); ui->menuExperimenta->setEnabled(false); ui->actionSave_Laplace_Matrix->setEnabled(false); connect(ui->glWidget, SIGNAL(faceCount(int)), ui->faceCount, SLOT(display(int))); connect(ui->glWidget, SIGNAL(vertexCount(int)), ui->vertexCount, SLOT(display(int))); connect(ui->radioButton, SIGNAL(toggled(bool)), ui->glWidget, SLOT(Light0State(bool))); connect(ui->radioButton_2, SIGNAL(toggled(bool)), ui->glWidget, SLOT(Light1State(bool))); connect(ui->radioButton_3, SIGNAL(toggled(bool)), ui->glWidget, SLOT(Light2State(bool))); connect(ui->glWidget,SIGNAL(SendVector(VectorXd)), &plotWin, SLOT(getVector(VectorXd))); connect(&posLight, SIGNAL(posX(int)), ui->glWidget, SLOT(LightPosX(int))); connect(&posLight, SIGNAL(posY(int)), ui->glWidget, SLOT(LightPosY(int))); connect(&posLight, SIGNAL(posZ(int)), ui->glWidget, SLOT(LightPosZ(int))); connect(&matWin, SIGNAL(amb(QColor)), ui->glWidget, SLOT(glAmb(QColor))); connect(&matWin, SIGNAL(diffuse(QColor)), ui->glWidget, SLOT(glDiffuse(QColor))); connect(&matWin, SIGNAL(spec(QColor)), ui->glWidget, SLOT(glSpec(QColor))); connect(&posLight, SIGNAL(sendLightColor(QColor)), ui->glWidget, SLOT(LightColor(QColor))); connect(&selectLaplacian, SIGNAL(selectKind(int)), ui->glWidget, SLOT(SelectLaplace(int))); connect(this, SIGNAL(sendEigenIndex(int)), ui->glWidget, SLOT(SeekEigen(int))); connect(this, SIGNAL(sendCompressionVolume(int)), ui->glWidget, SLOT(AdjustCompression(int))); connect(this, SIGNAL(analyseCurve()), ui->glWidget, SLOT(AnalyseCurve())); connect(ui->glWidget, SIGNAL(Status(QString)), this, SLOT(setStatus(QString))); connect(this, SIGNAL(shadingMode(int)), ui->glWidget, SLOT(selectShade(int))); }
void MyGLWidget::createBuffers () { // Carreguem el model de l'OBJ - Atenció! Abans de crear els buffers! //patr.load("/assig/idi/models/Patricio.obj"); patr.load("/assig/idi/models/Patricio.obj"); // Calculem la capsa contenidora del model calculaCapsaModel (); // Creació del Vertex Array Object del Patricio glGenVertexArrays(1, &VAO_Patr); glBindVertexArray(VAO_Patr); // Creació dels buffers del model patr // Buffer de posicions glGenBuffers(1, &VBO_PatrPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrPos); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_vertices(), GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); // Buffer de normals glGenBuffers(1, &VBO_PatrNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_normals(), GL_STATIC_DRAW); glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_PatrMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matamb(), GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_PatrMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matdiff(), GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_PatrMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matspec(), GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_PatrMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3, patr.VBO_matshin(), GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); // Dades del terra // VBO amb la posició dels vèrtexs glm::vec3 posterra[12] = { glm::vec3(-1.0, -1.0, 1.0), glm::vec3(1.0, -1.0, 1.0), glm::vec3(-1.0, -1.0, -1.0), glm::vec3(-1.0, -1.0, -1.0), glm::vec3(1.0, -1.0, 1.0), glm::vec3(1.0, -1.0, -1.0), glm::vec3(-1.0, -1.0, -1.0), glm::vec3(1.0, -1.0, -1.0), glm::vec3(-1.0, 1.0, -1.0), glm::vec3(-1.0, 1.0, -1.0), glm::vec3(1.0, -1.0, -1.0), glm::vec3(1.0, 1.0, -1.0) }; // VBO amb la normal de cada vèrtex glm::vec3 norm1 (0,1,0); glm::vec3 norm2 (0,0,1); glm::vec3 normterra[12] = { norm1, norm1, norm1, norm1, norm1, norm1, // la normal (0,1,0) per als primers dos triangles norm2, norm2, norm2, norm2, norm2, norm2 // la normal (0,0,1) per als dos últims triangles }; // Definim el material del terra glm::vec3 amb(0,0,1); glm::vec3 diff(0,0,1); glm::vec3 spec(1,1,1); float shin = 100; // Fem que aquest material afecti a tots els vèrtexs per igual glm::vec3 matambterra[12] = { amb, amb, amb, amb, amb, amb, amb, amb, amb, amb, amb, amb }; glm::vec3 matdiffterra[12] = { diff, diff, diff, diff, diff, diff, diff, diff, diff, diff, diff, diff }; glm::vec3 matspecterra[12] = { spec, spec, spec, spec, spec, spec, spec, spec, spec, spec, spec, spec }; float matshinterra[12] = { shin, shin, shin, shin, shin, shin, shin, shin, shin, shin, shin, shin }; // Creació del Vertex Array Object del terra glGenVertexArrays(1, &VAO_Terra); glBindVertexArray(VAO_Terra); glGenBuffers(1, &VBO_TerraPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraPos); glBufferData(GL_ARRAY_BUFFER, sizeof(posterra), posterra, GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); glGenBuffers(1, &VBO_TerraNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(normterra), normterra, GL_STATIC_DRAW); // Activem l'atribut normalLoc glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_TerraMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(matambterra), matambterra, GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_TerraMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(matdiffterra), matdiffterra, GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_TerraMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(matspecterra), matspecterra, GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_TerraMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(matshinterra), matshinterra, GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); glBindVertexArray(0); }
void MyGLWidget::createBuffers () { // Carreguem el model de l'OBJ - Atenció! Abans de crear els buffers! patr.load("./models/Patricio.obj"); // Calculem la capsa contenidora del model calculaCapsaModel (); // Creació del Vertex Array Object del Patricio glGenVertexArrays(1, &VAO_Patr); glBindVertexArray(VAO_Patr); // Creació dels buffers del model patr // Buffer de posicions glGenBuffers(1, &VBO_PatrPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrPos); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_vertices(), GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); // Buffer de normals glGenBuffers(1, &VBO_PatrNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_normals(), GL_STATIC_DRAW); glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_PatrMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matamb(), GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_PatrMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matdiff(), GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_PatrMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3*3, patr.VBO_matspec(), GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_PatrMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_PatrMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*patr.faces().size()*3, patr.VBO_matshin(), GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); // Dades del terra // VBO amb la posició dels vèrtexs glm::vec3 posterra[4] = { glm::vec3( 10.0, 0.0, -10.0), glm::vec3( 10.0, 0.0, 10.0), glm::vec3(-10.0, 0.0, -10.0), glm::vec3(-10.0, 0.0, 10.0) }; // VBO amb la normal de cada vèrtex glm::vec3 norm (0,1,0); glm::vec3 normterra[4] = { norm, norm, norm, norm }; // Definim el material del terra glm::vec3 amb(0.2,0.2,0.0); glm::vec3 diff(1.,1.,0.0); glm::vec3 spec(0.,0.,0.); float shin = 100; // Fem que aquest material afecti a tots els vèrtexs per igual glm::vec3 matambterra[4] = { amb, amb, amb, amb }; glm::vec3 matdiffterra[4] = { diff, diff, diff, diff }; glm::vec3 matspecterra[4] = { spec, spec, spec, spec }; float matshinterra[4] = { shin, shin, shin, shin }; // Creació del Vertex Array Object del terra glGenVertexArrays(1, &VAO_Terra); glBindVertexArray(VAO_Terra); glGenBuffers(1, &VBO_TerraPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraPos); glBufferData(GL_ARRAY_BUFFER, sizeof(posterra), posterra, GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); glGenBuffers(1, &VBO_TerraNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(normterra), normterra, GL_STATIC_DRAW); // Activem l'atribut normalLoc glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_TerraMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(matambterra), matambterra, GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_TerraMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(matdiffterra), matdiffterra, GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_TerraMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(matspecterra), matspecterra, GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_TerraMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(matshinterra), matshinterra, GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); glm::vec3 colorF(0.8, 0.8, 0.8); PosicionEstandarFoco = glm::vec3(5., 3., 5.); glUniform3fv(colFocusLoc, 1, &colorF[0]); glUniform3fv(posFocusLoc, 1, &PosicionEstandarFoco[0]); glUniform3fv(llumAmbiLoc, 1, &colorF[0]); glBindVertexArray(0); }
/*! Parses a Position Weight Matrices string Parses string containing position weight matrix definitions \param[in] std::string file */ bool PWM::parse(const std::string& matrix){ size_t thresh = matrix.find("THRESHOLD DEFINITION"); size_t track = matrix.find("TRACK SYMBOL DEFINITIONS"); size_t ambig = matrix.find("AMBIGUOUS SYMBOL DEFINITIONS"); size_t pwm = matrix.find("POSITION WEIGHT DEFINITIONS"); size_t back = matrix.find("BACKGROUND DEFINITION"); size_t space = matrix.find("SPACER DEFINITIONS"); size_t blank; size_t nlChar; if (thresh != std::string::npos){ blank=matrix.find("\n\n",thresh); size_t nlCharEq = matrix.rfind("####\n",blank); size_t nlCharNum= matrix.rfind("====\n",blank); //Check for optional dividing line if (nlCharEq!=std::string::npos){ nlChar=nlCharEq+5; } else if (nlCharNum!=std::string::npos){ nlChar=nlCharNum+5; } else{ //No divider line nlChar=matrix.find("\n",thresh); nlChar++; } std::string thr (matrix.substr(nlChar,blank-nlChar)); if (!_parseThreshold(thr)){ return false; } } if (track != std::string::npos){ blank=matrix.find("\n\n",track); size_t nlCharEq = matrix.rfind("####\n",blank); size_t nlCharNum= matrix.rfind("====\n",blank); //Check for optional dividing line if (nlCharEq!=std::string::npos){ nlChar=nlCharEq+5; } else if (nlCharNum!=std::string::npos){ nlChar=nlCharNum+5; } else{ //No divider line nlChar=matrix.find("\n",track); nlChar++; } std::string trck (matrix.substr(nlChar,blank-nlChar)); if (!_parseTrack(trck)){ return false; } } else{ std::cerr << "Required section: TRACK SYMBOL DEFINITIONS missing from the model" << std::endl; return false; } if (ambig != std::string::npos){ blank=matrix.find("\n\n",ambig); size_t nlCharEq = matrix.rfind("####\n",blank); size_t nlCharNum= matrix.rfind("====\n",blank); //Check for optional dividing line if (nlCharEq!=std::string::npos){ nlChar=nlCharEq+5; } else if (nlCharNum!=std::string::npos){ nlChar=nlCharNum+5; } else{ //No divider line nlChar=matrix.find("\n",ambig); nlChar++; } std::string amb(matrix.substr(nlChar,blank-nlChar)); if (!_parseAmbiguous(amb)){ return false; } } if (back!= std::string::npos){ blank=matrix.find("\n\n",back); size_t nlCharEq = matrix.rfind("####\n",blank); size_t nlCharNum= matrix.rfind("====\n",blank); //Check for optional dividing line if (nlCharEq!=std::string::npos){ nlChar=nlCharEq+5; } else if (nlCharNum!=std::string::npos){ nlChar=nlCharNum+5; } else{ //No divider line nlChar=matrix.find("\n",back); nlChar++; } std::string background(matrix.substr(nlChar,blank-nlChar)); if (!_parseBackground(background)){ return false; } } //Parse the positions if (pwm != std::string::npos){ std::string positions = matrix.substr(pwm); _parsePositions(positions); } //Parse the Spacer Information if (space != std::string::npos){ blank=matrix.find("\n\n",space); size_t nlCharEq = matrix.rfind("####\n",blank); size_t nlCharNum= matrix.rfind("====\n",blank); //Check for optional dividing line if (nlCharEq!=std::string::npos){ nlChar=nlCharEq+5; } else if (nlCharNum!=std::string::npos){ nlChar=nlCharNum+5; } else{ //No divider line nlChar=matrix.find("\n",space); nlChar++; } std::string spacer(matrix.substr(nlChar,blank-nlChar)); if (!_parseSpacer(spacer)){ return false; } } _finalizeTransitions(); return true; }
void MyGLWidget::createBuffers () { // Carreguem el model de l'OBJ - Atenció! Abans de crear els buffers! caps.load("./models/cow.obj"); // Calculem la capsa contenidora del model calculaCapsaModel (); // Creació del Vertex Array Object del Patricio glGenVertexArrays(1, &VAO_Caps); glBindVertexArray(VAO_Caps); // Creació dels buffers del model patr // Buffer de posicions glGenBuffers(1, &VBO_CapsPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsPos); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3*3, caps.VBO_vertices(), GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); // Buffer de normals glGenBuffers(1, &VBO_CapsNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3*3, caps.VBO_normals(), GL_STATIC_DRAW); glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_CapsMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3*3, caps.VBO_matamb(), GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_CapsMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3*3, caps.VBO_matdiff(), GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_CapsMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3*3, caps.VBO_matspec(), GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_CapsMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_CapsMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps.faces().size()*3, caps.VBO_matshin(), GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); // Carreguem el model de l'OBJ - Atenció! Abans de crear els buffers! caps2.load("./models/Patricio.obj"); // Calculem la capsa contenidora del model calculaCapsaModel2 (); // Creació del Vertex Array Object del Patricio glGenVertexArrays(1, &VAO_Caps2); glBindVertexArray(VAO_Caps2); // Creació dels buffers del model patr // Buffer de posicions glGenBuffers(1, &VBO_Caps2Pos); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Pos); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3*3, caps2.VBO_vertices(), GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); // Buffer de normals glGenBuffers(1, &VBO_Caps2Norm); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Norm); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3*3, caps2.VBO_normals(), GL_STATIC_DRAW); glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_Caps2Matamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Matamb); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3*3, caps2.VBO_matamb(), GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_Caps2Matdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Matdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3*3, caps2.VBO_matdiff(), GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_Caps2Matspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Matspec); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3*3, caps2.VBO_matspec(), GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_Caps2Matshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_Caps2Matshin); glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*caps2.faces().size()*3, caps2.VBO_matshin(), GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); // Dades del terra // VBO amb la posició dels vèrtexs glm::vec3 posterra[12] = { glm::vec3(-2.0, -1.0, 2.0), glm::vec3(2.0, -1.0, 2.0), glm::vec3(-2.0, -1.0, -2.0), glm::vec3(-2.0, -1.0, -2.0), glm::vec3(2.0, -1.0, 2.0), glm::vec3(2.0, -1.0, -2.0), glm::vec3(-2.0, -1.0, -2.0), glm::vec3(2.0, -1.0, -2.0), glm::vec3(-2.0, 1.0, -2.0), glm::vec3(-2.0, 1.0, -2.0), glm::vec3(2.0, -1.0, -2.0), glm::vec3(2.0, 1.0, -2.0) }; //________________________________________________________________ //___________________CALCUL MAX I MIN TERRA_______________________ maxTerra.x = minTerra.x = posterra[0].x; maxTerra.y = minTerra.y = posterra[0].y; maxTerra.z = minTerra.z = posterra[0].z; for (unsigned int i = 0; i < 12; i+=1) { if (posterra[i].x < minTerra.x) minTerra.x = posterra[i].x; if (posterra[i].x > maxTerra.x) maxTerra.x = posterra[i].x; if (posterra[i].y < minTerra.y) minTerra.y = posterra[i].y; if (posterra[i].y > maxTerra.y) maxTerra.y = posterra[i].y; if (posterra[i].z < minTerra.z) minTerra.z = posterra[i].z; if (posterra[i].z > maxTerra.z) maxTerra.z = posterra[i].z; } centreTerra.x = (minTerra.x+maxTerra.x)/2.0; centreTerra.y = (minTerra.y+maxTerra.y)/2.0; centreTerra.z = (minTerra.z+maxTerra.z)/2.0; //________________________________________________________ //_______________FI CALCUL________________________________ // VBO amb la normal de cada vèrtex glm::vec3 norm1 (0,1,0); glm::vec3 norm2 (0,0,1); glm::vec3 normterra[12] = { norm1, norm1, norm1, norm1, norm1, norm1, // la normal (0,1,0) per als primers dos triangles norm2, norm2, norm2, norm2, norm2, norm2 // la normal (0,0,1) per als dos últims triangles }; // Definim el material del terra glm::vec3 amb(0.2,0,0.2); glm::vec3 diff(0.8,0,0.8); glm::vec3 spec(0,0,0); float shin = 100; // Fem que aquest material afecti a tots els vèrtexs per igual glm::vec3 matambterra[12] = { amb, amb, amb, amb, amb, amb, amb, amb, amb, amb, amb, amb }; glm::vec3 matdiffterra[12] = { diff, diff, diff, diff, diff, diff, diff, diff, diff, diff, diff, diff }; glm::vec3 matspecterra[12] = { spec, spec, spec, spec, spec, spec, spec, spec, spec, spec, spec, spec }; float matshinterra[12] = { shin, shin, shin, shin, shin, shin, shin, shin, shin, shin, shin, shin }; // Creació del Vertex Array Object del terra glGenVertexArrays(1, &VAO_Terra); glBindVertexArray(VAO_Terra); glGenBuffers(1, &VBO_TerraPos); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraPos); glBufferData(GL_ARRAY_BUFFER, sizeof(posterra), posterra, GL_STATIC_DRAW); // Activem l'atribut vertexLoc glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertexLoc); glGenBuffers(1, &VBO_TerraNorm); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraNorm); glBufferData(GL_ARRAY_BUFFER, sizeof(normterra), normterra, GL_STATIC_DRAW); // Activem l'atribut normalLoc glVertexAttribPointer(normalLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(normalLoc); // En lloc del color, ara passem tots els paràmetres dels materials // Buffer de component ambient glGenBuffers(1, &VBO_TerraMatamb); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatamb); glBufferData(GL_ARRAY_BUFFER, sizeof(matambterra), matambterra, GL_STATIC_DRAW); glVertexAttribPointer(matambLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matambLoc); // Buffer de component difusa glGenBuffers(1, &VBO_TerraMatdiff); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatdiff); glBufferData(GL_ARRAY_BUFFER, sizeof(matdiffterra), matdiffterra, GL_STATIC_DRAW); glVertexAttribPointer(matdiffLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matdiffLoc); // Buffer de component especular glGenBuffers(1, &VBO_TerraMatspec); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatspec); glBufferData(GL_ARRAY_BUFFER, sizeof(matspecterra), matspecterra, GL_STATIC_DRAW); glVertexAttribPointer(matspecLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matspecLoc); // Buffer de component shininness glGenBuffers(1, &VBO_TerraMatshin); glBindBuffer(GL_ARRAY_BUFFER, VBO_TerraMatshin); glBufferData(GL_ARRAY_BUFFER, sizeof(matshinterra), matshinterra, GL_STATIC_DRAW); glVertexAttribPointer(matshinLoc, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(matshinLoc); glBindVertexArray(0); }