// 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;
