int WINAPI QERApp_LoadFile( const char *pLocation, void ** buffer ) { char cPath[1024]; sprintf( cPath, "%s/%s", ValueForKey(g_qeglobals.d_project_entity, "basepath"), pLocation); int nSize = LoadFile( cPath, buffer); if (nSize == -1) { nSize = PakLoadAnyFile(cPath, buffer); } return nSize; }
void WINAPI QERApp_LoadShaderFile (const char* filename) { char* pBuff = NULL; int nSize = LoadFile(filename, reinterpret_cast<void**>(&pBuff)); if (nSize == -1) nSize = PakLoadAnyFile(filename, reinterpret_cast<void**>(&pBuff)); if (nSize > 0) { Sys_Printf("Parsing shaderfile %s\n", filename); StartTokenParsing(pBuff); while (GetToken(true)) { // first token should be the path + name.. (from base) CShader *pShader = new CShader(); // we want the relative filename only, it's easier for later lookup .. see QERApp_ReloadShaderFile char cTmp[1024]; QE_ConvertDOSToUnixName( cTmp, filename ); pShader->setShaderFileName( filename + strlen(ValueForKey(g_qeglobals.d_project_entity, "basepath")) + 1); if (pShader->Parse()) { // do we already have this shader? //++timo NOTE: this may a bit slow, we may need to use a map instead of a dumb list if (g_Shaders.Shader_ForName( pShader->getName() ) != NULL) { Sys_Printf( "WARNING: shader %s is already in memory, definition in %s ignored.\n", pShader->getName(), filename ); delete pShader; } else { pShader->IncRef(); g_Shaders.Add( (LPVOID)pShader ); int n = g_PrefsDlg.m_nShader; if ((g_PrefsDlg.m_nShader == CPrefsDlg::SHADER_ALL) || (g_PrefsDlg.m_nShader == CPrefsDlg::SHADER_COMMON && strstr(pShader->getName(), "common" ))) // load the qtexture and display in tex wnd pShader->Activate(); } } else { Sys_Printf("Error parsing shader %s\n", pShader->getName()); delete pShader; } } free (pBuff); } else { Sys_Printf("Unabled to read shaderfile %s\n", filename); } }
// bool return really, but needs an int to match header proto which is included by a C file, and MS C compiler // doesn't like bool types // int LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) { bool bReturn = true; *pic = NULL; /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just * take the easy way out and use the standard error handler, which will * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct jpeg_error_mgr jerr; /* More stuff */ JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ unsigned char *out; byte *fbuffer; byte *bbuf; /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ //stefix #if 0 ri.FS_ReadFile ( ( char * ) filename, (void **)&fbuffer); if (!fbuffer) return false; #else int iLoadedLen = LoadFile (filename, (void **)&fbuffer); if (iLoadedLen == -1) { iLoadedLen = PakLoadAnyFile(filename, (void **)&fbuffer); if (iLoadedLen == -1) { return false; } } #endif try { /* Step 1: allocate and initialize JPEG decompression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error(&jerr); /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_stdio_src(&cinfo, fbuffer); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* Step 4: set parameters for decompression */ /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; if (cinfo.output_components!=4 && cinfo.output_components!=1 ) { throw(va("JPG %s is unsupported color depth (%d)\n", filename, cinfo.output_components)); } out = (byte *)malloc(cinfo.output_width*cinfo.output_height*4); *pic = out; *width = cinfo.output_width; *height = cinfo.output_height; /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ bbuf = ((out+(row_stride*cinfo.output_scanline))); buffer = &bbuf; (void) jpeg_read_scanlines(&cinfo, buffer, 1); } // if we've just loaded a greyscale, then adjust it from 8-bit to 32bit by stretch-copying it over itself... // (this also does the alpha stuff as well) // if (cinfo.output_components == 1) { byte *pbDest = (*pic + (cinfo.output_width * cinfo.output_height * 4))-1; byte *pbSrc = (*pic + (cinfo.output_width * cinfo.output_height ))-1; int iPixels = cinfo.output_width * cinfo.output_height; for (int i=0; i<iPixels; i++) { byte b = *pbSrc--; *pbDest-- = 255; *pbDest-- = b; *pbDest-- = b; *pbDest-- = b; } } else {// clear all the alphas to 255 int i, j; byte *buf; buf = *pic; j = cinfo.output_width * cinfo.output_height * 4; for ( i = 3 ; i < j ; i+=4 ) { buf[i] = 255; } } /* Step 7: Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); } catch(LPCSTR psMessage) { //ErrorBox Sys_Printf(va("JPEG read error: %s",psMessage)); jpeg_destroy_decompress(&cinfo); bReturn = false; if (*pic) { free(*pic); *pic = NULL; } } /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ //stefix #if 0 ri.FS_FreeFile (fbuffer); #else free(fbuffer); #endif /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ return bReturn; }
// FIXME: this code is a TOTAL clusterfuck // void LoadModel(const char *pLocation, eclass_t *e, vec3_t &vMin, vec3_t &vMax, entitymodel *&pModel, const char *pSkin) { // this assumes a path only and uses tris.md2 // for the model and skin.pcx for the skin char cPath[1024]; char cSkin[1024]; char cFullLocation[1024]; //struct _finddata_t fileinfo; vMin[0] = vMin[1] = vMin[2] = 99999; vMax[0] = vMax[1] = vMax[2] = -99999; bool bMD3 = false; bool bASE = false; strcpy( cFullLocation, pLocation ); if (strstr(pLocation, ".md3")) { bMD3 = true; } else if (strstr(pLocation, ".md2") != NULL) { sprintf( cFullLocation, "%stris.md2", pLocation); } else if (strstr(pLocation, ".ase") != NULL) { bASE = true; } sprintf( cPath, "%s/%s", ValueForKey(g_qeglobals.d_project_entity, "basepath"), cFullLocation); Sys_Printf("Loading model %s...", cPath); unsigned char* p = NULL; bool bOpen = (LoadFile(cPath, reinterpret_cast<void**>(&p)) > 0); if (!bOpen) { Sys_Printf(" failed. Trying PAK file..."); // sprintf (cPath, "%stris.md2", pLocation); strcpy (cPath, cFullLocation); bOpen = (PakLoadAnyFile(cPath, reinterpret_cast<void**>(&p)) > 0); } if (bOpen) { Sys_Printf(" successful.\n"); if (bASE) { /* free(p); CString strOut; ::GetTempPath(1024, strOut.GetBuffer(1024)); strOut.ReleaseBuffer(); AddSlash(strOut); strOut += "Temp.ase"; CopyFile(cPath, strOut, false); CString strIn = strOut; FindReplace(strOut, ".ase", ".md3"); strcpy(cPath, strIn); strcpy(cSkin, strOut); Q3Data_ProduceTempMD3(ValueForKey(g_qeglobals.d_project_entity, "basepath"), cPath, cSkin); CString strModel = cPath; if (LoadFile(strOut.GetBuffer(0), reinterpret_cast<void**>(&p)) == 0) { Sys_Printf(" Conversion from ASE failed.\n"); return; } bMD3 = true; */ } if (bMD3) { md3Header_t header; md3Surface_t *pSurface; header = *(md3Header_t *)p; if (pSkin != NULL) { strcpy(cSkin, pSkin); } else { cSkin[0] = '\0'; } int n = header.numFrames; pSurface = (md3Surface_t *) (p + header.ofsSurfaces); for (int z = 0; z < header.numSurfaces; z++ ) { int nTris = pSurface->numTriangles; //unsigned char* pTris = reinterpret_cast<unsigned char*>(pSurface); //pTris += pSurface->ofsTriangles; if (nTris > 0) { int nStart = 0; if (pModel->pTriList == NULL) { pModel->nModelPosition = 0; pModel->pTriList = new trimodel[nTris]; pModel->nTriCount = nTris; } else { // already have one so we need to reallocate int nNewCount = pModel->nTriCount + nTris; trimodel* pNewModels = new trimodel[nNewCount]; for (int i = 0; i < pModel->nTriCount; i++) { memcpy(&pNewModels[i], &pModel->pTriList[i], sizeof(trimodel)); } nStart = pModel->nTriCount; pModel->nTriCount = nNewCount; //nTris = nNewCount; delete [] pModel->pTriList; pModel->pTriList = pNewModels; } md3Triangle_t *pTris = reinterpret_cast<md3Triangle_t*>((reinterpret_cast<unsigned char*>(pSurface) + pSurface->ofsTriangles)); md3XyzNormal_t *pXyz = reinterpret_cast<md3XyzNormal_t*>((reinterpret_cast<unsigned char*>(pSurface) + pSurface->ofsXyzNormals)); if (e->nFrame < pSurface->numFrames) { pXyz += (e->nFrame * pSurface->numVerts); } md3St_t *pST = reinterpret_cast<md3St_t*>((reinterpret_cast<unsigned char*>(pSurface) + pSurface->ofsSt)); for (int i = 0; i < nTris; i++) { for (int k = 0; k < 3; k ++) { for (int j = 0; j < 3; j++) { //e->pTriList[i].v[k][j] = (f->verts[tri.index_xyz[k]].v[j] * f->scale[j] + f->translate[j]); pModel->pTriList[nStart].v[k][j] = pXyz[pTris[i].indexes[k]].xyz[j] * MD3_XYZ_SCALE; } pModel->pTriList[nStart].st[k][0] = pST[pTris[i].indexes[k]].st[0]; pModel->pTriList[nStart].st[k][1] = pST[pTris[i].indexes[k]].st[1]; ExtendBounds (pModel->pTriList[nStart].v[k], vMin, vMax); } nStart++; } } md3Shader_t *pShader = reinterpret_cast<md3Shader_t*>((reinterpret_cast<unsigned char*>(pSurface) + pSurface->ofsShaders)); sprintf (cPath, "%s/%s", ValueForKey(g_qeglobals.d_project_entity, "basepath"), pShader->name); strlwr(cPath); pModel->nTextureBind = Texture_LoadSkin(cPath, &pModel->nSkinWidth, &pModel->nSkinHeight); if (pModel->nTextureBind == -1) { Sys_Printf("Model skin load failed on texture %s\n", cPath); } pSurface = (md3Surface_t *) ((( char * ) pSurface) + pSurface->ofsEnd); pModel->pNext = reinterpret_cast<entitymodel_t*>(qmalloc(sizeof(entitymodel_t))); pModel = pModel->pNext; } } else { dmdl_t model; daliasframe_t *f; unsigned char* pTris = p; dstvert_t *pST = NULL; int nTris = 0; // grab model params memcpy(&model, p, sizeof(dmdl_t)); f = (daliasframe_t*)(p + model.ofs_frames); pTris += model.ofs_tris; pST = reinterpret_cast<dstvert_t*>(p + model.ofs_st); nTris = model.num_tris; if(pSkin) { strcpy (cSkin, pSkin); if ((cSkin[strlen(cSkin)-1] == '\\') || (cSkin[strlen(cSkin)-1] == '/')) strcat(cSkin, "skin.pcx\0"); } else { strcpy(cSkin, (char *)(p + model.ofs_skins)); } sprintf (cPath, "%s/%s", ValueForKey(g_qeglobals.d_project_entity, "basepath"), cSkin); strlwr(cPath); pModel->nTextureBind = Texture_LoadSkin(cPath, &pModel->nSkinWidth, &pModel->nSkinHeight); if (pModel->nTextureBind == -1) { Sys_Printf("Model skin load failed on texture %s\n", cPath); } int nStart = 0; if (pModel->pTriList == NULL) { pModel->nModelPosition = 0; pModel->pTriList = new trimodel[nTris]; pModel->nTriCount = nTris; } else { // already have one so we need to reallocate int nNewCount = pModel->nTriCount + nTris; trimodel* pNewModels = new trimodel[nNewCount]; for (int i = 0; i < pModel->nTriCount; i++) { memcpy(&pNewModels[i], &pModel->pTriList[i], sizeof(trimodel)); } nStart = pModel->nTriCount; pModel->nTriCount = nNewCount; nTris = nNewCount; delete [] pModel->pTriList; pModel->pTriList = pNewModels; } for (int i = nStart; i < nTris; i++) { dtriangle_t tri; memcpy(&tri, pTris, sizeof(dtriangle_t)); for (int k = 0; k < 3; k ++) { for (int j = 0; j < 3; j++) { pModel->pTriList[i].v[k][j] = (f->verts[tri.index_xyz[k]].v[j] * f->scale[j] + f->translate[j]); } pModel->pTriList[i].st[k][0] = pST[tri.index_st[k]].s / pModel->nSkinWidth; pModel->pTriList[i].st[k][1] = pST[tri.index_st[k]].t / pModel->nSkinHeight;; ExtendBounds (pModel->pTriList[i].v[k], vMin, vMax); } pTris += sizeof(dtriangle_t); } } free(p); } else { Sys_Printf(" failed.\n"); } #if 0 if (pModel->pTriList != NULL && pModel->nTriCount > 0 && !bMD3) { if(fabs(vMin[2]) < ((vMax[2]-vMin[2]) / 10.0)) // > 90% above 0 point. pModel->nModelPosition = 1; // sprintf (cPath, "%s/%sskin.pcx", ValueForKey(g_qeglobals.d_project_entity, "basepath"), pLocation); sprintf (cPath, "%s/%s", ValueForKey(g_qeglobals.d_project_entity, "basepath"), cSkin); pModel->nTextureBind = Texture_LoadSkin(cPath, &pModel->nSkinWidth, &pModel->nSkinHeight); if (pModel->nTextureBind == -1) { // sprintf (cPath, "%sskin.pcx", pLocation); strcpy (cPath, cSkin); pModel->nTextureBind = Texture_LoadSkin(cPath, &pModel->nSkinWidth, &pModel->nSkinHeight); } } #endif }