// Loads and compiles shader. // sFile - path to a file // a_iType - type of shader(fragment, vertex, geometry) bool CShader::loadShader(string sFile, int a_iType) { FILE* fp = fopen(sFile.c_str(), "rt"); if(!fp)return false; // Get all lines from a file vector<string> sLines; char sLine[255]; while(fgets(sLine, 255, fp))sLines.push_back(sLine); fclose(fp); const char** sProgram = new const char*[ESZ(sLines)]; FOR(i, ESZ(sLines))sProgram[i] = sLines[i].c_str(); uiShader = glCreateShader(a_iType); glShaderSource(uiShader, ESZ(sLines), sProgram, NULL); glCompileShader(uiShader); delete[] sProgram; int iCompilationStatus; glGetShaderiv(uiShader, GL_COMPILE_STATUS, &iCompilationStatus); if(iCompilationStatus == GL_FALSE)return false; iType = a_iType; bLoaded = true; return 1; }
struct elfinfo *readelf(int fd, const char *filename) { struct elfinfo *e = malloc(sizeof(*e)); int phsz; assert(e); e->fd = fd; if (pread(fd, &e->e, sizeof(e->e), 0) != sizeof(e->e)) { fprintf(stderr, "valgrind: %s: can't read elf header: %s\n", filename, strerror(errno)); return NULL; } if (memcmp(&e->e.e_ident[0], ELFMAG, SELFMAG) != 0) { fprintf(stderr, "valgrind: %s: bad ELF magic\n", filename); return NULL; } if (e->e.e_ident[EI_CLASS] != VG_ELF_CLASS) { fprintf(stderr, "valgrind: wrong executable class (eg. 32-bit instead\n" "valgrind: of 64-bit)\n"); return NULL; } if (e->e.e_ident[EI_DATA] != VG_ELF_ENDIANNESS) { fprintf(stderr, "valgrind: wrong endian-ness\n"); return NULL; } if (!(e->e.e_type == ET_EXEC || e->e.e_type == ET_DYN)) { fprintf(stderr, "valgrind: need executable\n"); return NULL; } if (e->e.e_machine != VG_ELF_MACHINE) { fprintf(stderr, "valgrind: wrong architecture\n"); return NULL; } if (e->e.e_phentsize != sizeof(ESZ(Phdr))) { fprintf(stderr, "valgrind: sizeof Phdr wrong\n"); return NULL; } phsz = sizeof(ESZ(Phdr)) * e->e.e_phnum; e->p = malloc(phsz); assert(e->p); if (pread(fd, e->p, phsz, e->e.e_phoff) != phsz) { fprintf(stderr, "valgrind: can't read phdr: %s\n", strerror(errno)); return NULL; } return e; }
struct elfinfo *readelf(int fd, const char *filename) { struct elfinfo *e = malloc(sizeof(*e)); int phsz; assert(e); e->fd = fd; if (pread(fd, &e->e, sizeof(e->e), 0) != sizeof(e->e)) { fprintf(stderr, "valgrind: %s: can't read elf header: %s\n", filename, strerror(errno)); return NULL; } if (memcmp(&e->e.e_ident[0], ELFMAG, SELFMAG) != 0) { fprintf(stderr, "valgrind: %s: bad ELF magic\n", filename); return NULL; } if (e->e.e_ident[EI_CLASS] != ELFCLASS32) { fprintf(stderr, "valgrind: Can only handle 32-bit executables\n"); return NULL; } if (e->e.e_ident[EI_DATA] != ELFDATA2LSB) { fprintf(stderr, "valgrind: Expecting little-endian\n"); return NULL; } if (!(e->e.e_type == ET_EXEC || e->e.e_type == ET_DYN)) { fprintf(stderr, "valgrind: need executable\n"); return NULL; } if (e->e.e_machine != EM_386) { fprintf(stderr, "valgrind: need x86\n"); return NULL; } if (e->e.e_phentsize != sizeof(ESZ(Phdr))) { fprintf(stderr, "valgrind: sizeof Phdr wrong\n"); return NULL; } phsz = sizeof(ESZ(Phdr)) * e->e.e_phnum; e->p = malloc(phsz); assert(e->p); if (pread(fd, e->p, phsz, e->e.e_phoff) != phsz) { fprintf(stderr, "valgrind: can't read phdr: %s\n", strerror(errno)); return NULL; } return e; }
string getDirectoryPath(string sFilePath) { // Get directory path string sDirectory = ""; RFOR(i, ESZ(sFilePath)-1)if(sFilePath[i] == '\\' || sFilePath[i] == '/') { sDirectory = sFilePath.substr(0, i+1); break; } return sDirectory; }
vector<string> split(string s, string t) { vector<string> res; while(1) { int pos = s.find(t); if(pos == -1){res.push_back(s); break;} res.push_back(s.substr(0, pos)); s = s.substr(pos+1, ESZ(s)-pos-1); } return res; }
bool PrepareShaderPrograms() { // Load shaders and create shader program string sShaderFileNames[] = {"main_shader.vert", "main_shader.frag", "ortho2D.vert", "ortho2D.frag", "font2D.frag", "dirLight.frag", "normal_displayer.vert", "normal_displayer.geom", "normal_displayer.frag" }; FOR(i, NUMSHADERS) { string sExt = sShaderFileNames[i].substr(ESZ(sShaderFileNames[i])-4, 4); int iShaderType = sExt == "vert" ? GL_VERTEX_SHADER : (sExt == "frag" ? GL_FRAGMENT_SHADER : GL_GEOMETRY_SHADER); shShaders[i].LoadShader("data\\shaders\\"+sShaderFileNames[i], iShaderType); }
if (seg->kind == SkAnonC || seg->kind == SkShmC || (seg->kind == SkFileC && !VKI_S_ISCHR(seg->mode) && !VKI_S_ISBLK(seg->mode))) return True; return False; } /* If true, then this Segment's contents will be in the core */ static Bool should_dump(const NSegment *seg) { return may_dump(seg); // && seg->hasW; } static void fill_ehdr(ESZ(Ehdr) *ehdr, Int num_phdrs) { VG_(memset)(ehdr, 0, sizeof(*ehdr)); VG_(memcpy)(ehdr->e_ident, ELFMAG, SELFMAG); ehdr->e_ident[EI_CLASS] = VG_ELF_CLASS; ehdr->e_ident[EI_DATA] = VG_ELF_DATA2XXX; ehdr->e_ident[EI_VERSION] = EV_CURRENT; ehdr->e_type = ET_CORE; ehdr->e_machine = VG_ELF_MACHINE; ehdr->e_version = EV_CURRENT; ehdr->e_entry = 0; ehdr->e_phoff = sizeof(ESZ(Ehdr)); ehdr->e_shoff = 0; ehdr->e_flags = 0;
static struct elfinfo *readelf(Int fd, const char *filename) { SysRes sres; struct elfinfo *e = VG_(malloc)("ume.re.1", sizeof(*e)); Int phsz; vg_assert(e); e->fd = fd; sres = VG_(pread)(fd, &e->e, sizeof(e->e), 0); if (sr_isError(sres) || sr_Res(sres) != sizeof(e->e)) { VG_(printf)("valgrind: %s: can't read ELF header: %s\n", filename, VG_(strerror)(sr_Err(sres))); goto bad; } if (VG_(memcmp)(&e->e.e_ident[0], ELFMAG, SELFMAG) != 0) { VG_(printf)("valgrind: %s: bad ELF magic number\n", filename); goto bad; } if (e->e.e_ident[EI_CLASS] != VG_ELF_CLASS) { VG_(printf)("valgrind: wrong ELF executable class " "(eg. 32-bit instead of 64-bit)\n"); goto bad; } if (e->e.e_ident[EI_DATA] != VG_ELF_DATA2XXX) { VG_(printf)("valgrind: executable has wrong endian-ness\n"); goto bad; } if (!(e->e.e_type == ET_EXEC || e->e.e_type == ET_DYN)) { VG_(printf)("valgrind: this is not an executable\n"); goto bad; } if (e->e.e_machine != VG_ELF_MACHINE) { VG_(printf)("valgrind: executable is not for " "this architecture\n"); goto bad; } if (e->e.e_phentsize != sizeof(ESZ(Phdr))) { VG_(printf)("valgrind: sizeof ELF Phdr wrong\n"); goto bad; } phsz = sizeof(ESZ(Phdr)) * e->e.e_phnum; e->p = VG_(malloc)("ume.re.2", phsz); vg_assert(e->p); sres = VG_(pread)(fd, e->p, phsz, e->e.e_phoff); if (sr_isError(sres) || sr_Res(sres) != phsz) { VG_(printf)("valgrind: can't read phdr: %s\n", VG_(strerror)(sr_Err(sres))); VG_(free)(e->p); goto bad; } return e; bad: VG_(free)(e); return NULL; }
bool CObjModel::loadModel(string sFileName, string sMtlFileName) { FILE* fp = fopen(sFileName.c_str(), "rt"); if(fp == NULL)return false; char line[255]; vector<glm::vec3> vVertices; vector<glm::vec2> vTexCoords; vector<glm::vec3> vNormals; iNumFaces = 0; while(fgets(line, 255, fp)) { // Error flag, that can be set when something is inconsistent throughout // data parsing bool bError = false; // If it's an empty line, then skip if(strlen(line) <= 1) continue; // Now we're going to process line stringstream ss(line); string sType; ss >> sType; // If it's a comment, skip it if(sType == "#") continue; // Vertex else if(sType == "v") { glm::vec3 vNewVertex; int dim = 0; while(dim < 3 && ss >> vNewVertex[dim])dim++; vVertices.push_back(vNewVertex); iAttrBitField |= 1; } // Texture coordinate else if(sType == "vt") { glm::vec2 vNewCoord; int dim = 0; while(dim < 2 && ss >> vNewCoord[dim])dim++; vTexCoords.push_back(vNewCoord); iAttrBitField |= 2; } // Normal else if(sType == "vn") { glm::vec3 vNewNormal; int dim = 0; while(dim < 3 && ss >> vNewNormal[dim])dim++; vNewNormal = glm::normalize(vNewNormal); vNormals.push_back(vNewNormal); iAttrBitField |= 4; } // Face definition else if(sType == "f") { string sFaceData; // This will run for as many vertex definitions as the face has // (for triangle, it's 3) while(ss >> sFaceData) { vector<string> data = split(sFaceData, "/"); int iVertIndex = -1, iTexCoordIndex = -1, iNormalIndex = -1; // If there were some vertices defined earlier if(iAttrBitField&1) { if(ESZ(data[0]) > 0)sscanf(data[0].c_str(), "%d", &iVertIndex); else bError = true; } // If there were some texture coordinates defined earlier if(iAttrBitField&2 && !bError) { if(ESZ(data) >= 1) { // Just a check whether face format isn't f v//vn // In that case, data[1] is empty string if(ESZ(data[1]) > 0)sscanf(data[1].c_str(), "%d", &iTexCoordIndex); else bError = true; } else bError = true; } // If there were some normals defined defined earlier if(iAttrBitField&4 && !bError) { if(ESZ(data) >= 2) { if(ESZ(data[2]) > 0)sscanf(data[2].c_str(), "%d", &iNormalIndex); else bError = true; } else bError = true; } if(bError) { fclose(fp); return false; } // Check whether vertex index is within boundaries (indexed from 1) if(iVertIndex > 0 && iVertIndex <= ESZ(vVertices)) vboModelData.addData(&vVertices[iVertIndex-1], sizeof(glm::vec3)); if(iTexCoordIndex > 0 && iTexCoordIndex <= ESZ(vTexCoords)) vboModelData.addData(&vTexCoords[iTexCoordIndex-1], sizeof(glm::vec2)); if(iNormalIndex > 0 && iNormalIndex <= ESZ(vNormals)) vboModelData.addData(&vNormals[iNormalIndex-1], sizeof(glm::vec3)); } iNumFaces++; } // Shading model, for now just skip it else if(sType == "s")
of loading the ELF. Provides a final opportunity for architecture code to reject the loading of the ELF. This is called after all program headers to be checked by arch_elf_pt_proc have been. Return: Zero to proceed with the ELF load, non-zero to fail the ELF load with that return code. Ref: linux/fs/binfmt_elf.c */ # if defined(VGP_mips32_linux) /* Ref: linux/arch/mips/kernel/elf.c */ static inline Int arch_elf_pt_proc(ESZ(Ehdr) *ehdr, ESZ(Phdr) *phdr, Int fd, Bool is_interpreter, struct vki_arch_elf_state *state) { struct vki_mips_elf_abiflags_v0 abiflags; SysRes sres; if ( (ehdr->e_ident[EI_CLASS] == ELFCLASS32) && (ehdr->e_flags & VKI_EF_MIPS_FP64) ) { /* * Set MIPS_ABI_FP_OLD_64 for EF_MIPS_FP64. We will override it * later if needed */ if (is_interpreter) state->interp_fp_abi = VKI_MIPS_ABI_FP_OLD_64;