void WadImageCache::initialize_cache()
{
FileSpecifier info;
info.SetToImageCacheDir();
info.AddPart("Cache.ini");
if (!info.Exists())
return;
InfoTree pt;
try {
pt = InfoTree::load_ini(info);
} catch (InfoTree::ini_error e) {
logError("Could not read image cache from %s (%s)", info.GetPath(), e.what());
}
for (InfoTree::iterator it = pt.begin(); it != pt.end(); ++it)
{
std::string name = it->first;
InfoTree ptc = it->second;
WadImageDescriptor desc;
std::string path;
ptc.read("path", path);
desc.file = FileSpecifier(path);
ptc.read("checksum", desc.checksum);
ptc.read("index", desc.index);
ptc.read("tag", desc.tag);
int width = 0;
ptc.read("width", width);
int height = 0;
ptc.read("height", height);
size_t filesize = 0;
ptc.read("filesize", filesize);
cache_key_t key = cache_key_t(desc, width, height);
cache_value_t val = cache_value_t(name, filesize);
m_used.push_front(cache_pair_t(key, val));
m_cacheinfo[key] = m_used.begin();
m_cachesize += filesize;
}
}
bool PluginLoader::ParseDirectory(FileSpecifier& dir)
{
std::vector<dir_entry> de;
if (!dir.ReadDirectory(de)) {
return false;
}
for (std::vector<dir_entry>::const_iterator it = de.begin(); it != de.end();
++it) {
FileSpecifier file = dir + it->name;
if (it->name == "Plugin.xml") {
ParsePlugin(file);
}
else if (it->is_directory && it->name[0] != '.') {
ParseDirectory(file);
}
#ifdef HAVE_ZZIP
else if (algo::ends_with(it->name,
".zip") || algo::ends_with(it->name, ".ZIP")) {
// search it for a Plugin.xml file
ZZIP_DIR* zzipdir = zzip_dir_open(file.GetPath(), 0);
if (zzipdir) {
ZZIP_DIRENT dirent;
while (zzip_dir_read(zzipdir, &dirent))
{
if (algo::ends_with(dirent.d_name, "Plugin.xml")) {
std::string archive = file.GetPath();
FileSpecifier file_name =
FileSpecifier(archive.substr(0,
archive.find_last_of('.'))) +
dirent.d_name;
ParsePlugin(file_name);
}
}
zzip_dir_close(zzipdir);
}
}
#endif
}
return true;
}
// DJB OpenGL
char* parseFile(FileSpecifier& fileSpec) {
if (fileSpec == FileSpecifier() || !fileSpec.Exists()) {
return NULL;
}
OpenedFile file;
if (!fileSpec.Open(file)) {
fprintf(stderr, "%s not found\n", fileSpec.GetPath());
return NULL;
}
int32 length;
file.GetLength(length);
char* str = new char[length + 1];
file.Read(length, str);
str[length] = 0;
return str;
}
void OGL_ModelData::Load()
{
// Already loaded?
if (ModelPresent()) {
return;
}
// Load the model
Model.Clear();
if (ModelFile == FileSpecifier()) {
return;
}
if (!ModelFile.Exists()) {
return;
}
bool Success = false;
char *Type = &ModelType[0];
if (StringsEqual(Type,"wave",4)) {
// Alias|Wavefront
Success = LoadModel_Wavefront(ModelFile, Model);
}
else if (StringsEqual(Type,"3ds",3)) {
// 3D Studio Max
Success = LoadModel_Studio(ModelFile, Model);
}
else if (StringsEqual(Type,"dim3",4)) {
// Brian Barnes's "Dim3" model format (first pass: model geometry)
Success = LoadModel_Dim3(ModelFile, Model, LoadModelDim3_First);
// Second and third passes: frames and sequences
try
{
if (ModelFile1 == FileSpecifier()) {
throw 0;
}
if (!ModelFile1.Exists()) {
throw 0;
}
if (!LoadModel_Dim3(ModelFile1, Model, LoadModelDim3_Rest)) {
throw 0;
}
}
catch(...)
{}
//
try
{
if (ModelFile2 == FileSpecifier()) {
throw 0;
}
if (!ModelFile2.Exists()) {
throw 0;
}
if (!LoadModel_Dim3(ModelFile2, Model, LoadModelDim3_Rest)) {
throw 0;
}
}
catch(...)
{}
}
#if HAVE_QUESA
else if (StringsEqual(Type,
"qd3d") ||
StringsEqual(Type,"3dmf") || StringsEqual(Type,"quesa")) {
// QuickDraw 3D / Quesa
Success = LoadModel_QD3D(ModelFile, Model);
}
#endif
if (!Success) {
Model.Clear();
return;
}
// Calculate transformation matrix
GLfloat Angle, Cosine, Sine;
GLfloat RotMatrix[3][3], NewRotMatrix[3][3], IndivRotMatrix[3][3];
MatIdentity(RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*XRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[1][1] = Cosine;
IndivRotMatrix[1][2] = -Sine;
IndivRotMatrix[2][1] = Sine;
IndivRotMatrix[2][2] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*YRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[2][2] = Cosine;
IndivRotMatrix[2][0] = -Sine;
IndivRotMatrix[0][2] = Sine;
IndivRotMatrix[0][0] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*ZRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[0][0] = Cosine;
IndivRotMatrix[0][1] = -Sine;
IndivRotMatrix[1][0] = Sine;
IndivRotMatrix[1][1] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatScalMult(NewRotMatrix,Scale); // For the position vertices
if (Scale < 0) {
MatScalMult(RotMatrix,-1); // For the normals
}
// Is model animated or static?
// Test by trying to find neutral positions (useful for working with the normals later on)
if (Model.FindPositions_Neutral(false)) {
// Copy over the vector and normal transformation matrices:
for (int k=0; k<3; k++)
for (int l=0; l<3; l++)
{
Model.TransformPos.M[k][l] = NewRotMatrix[k][l];
Model.TransformNorm.M[k][l] = RotMatrix[k][l];
}
Model.TransformPos.M[0][3] = XShift;
Model.TransformPos.M[1][3] = YShift;
Model.TransformPos.M[2][3] = ZShift;
// Find the transformed bounding box:
bool RestOfCorners = false;
GLfloat NewBoundingBox[2][3];
// The indices i1, i2, and i3 are for selecting which of the box's two principal corners
// to get coordinates from
for (int i1=0; i1<2; i1++)
{
GLfloat X = Model.BoundingBox[i1][0];
for (int i2=0; i2<2; i2++)
{
GLfloat Y = Model.BoundingBox[i2][0];
for (int i3=0; i3<2; i3++)
{
GLfloat Z = Model.BoundingBox[i3][0];
GLfloat Corner[3];
for (int ic=0; ic<3; ic++)
{
GLfloat *Row = Model.TransformPos.M[ic];
Corner[ic] = Row[0]*X + Row[1]*Y + Row[2]*Z + Row[3];
}
if (RestOfCorners) {
// Find minimum and maximum for each coordinate
for (int ic=0; ic<3; ic++)
{
NewBoundingBox[0][ic] = min(NewBoundingBox[0][ic],Corner[ic]);
NewBoundingBox[1][ic] = max(NewBoundingBox[1][ic],Corner[ic]);
}
}
else
{
// Simply copy it in:
for (int ic=0; ic<3; ic++)
NewBoundingBox[0][ic] = NewBoundingBox[1][ic] = Corner[ic];
RestOfCorners = true;
}
}
}
}
for (int ic=0; ic<2; ic++)
objlist_copy(Model.BoundingBox[ic],NewBoundingBox[ic],3);
}
else
{
// Static model
size_t NumVerts = Model.Positions.size()/3;
for (size_t k=0; k<NumVerts; k++)
{
GLfloat *Pos = Model.PosBase() + 3*k;
GLfloat NewPos[3];
MatVecMult(NewRotMatrix,Pos,NewPos); // Has the scaling
Pos[0] = NewPos[0] + XShift;
Pos[1] = NewPos[1] + YShift;
Pos[2] = NewPos[2] + ZShift;
}
size_t NumNorms = Model.Normals.size()/3;
for (size_t k=0; k<NumNorms; k++)
{
GLfloat *Norms = Model.NormBase() + 3*k;
GLfloat NewNorms[3];
MatVecMult(RotMatrix,Norms,NewNorms); // Not scaled
objlist_copy(Norms,NewNorms,3);
}
// So as to be consistent with the new points
Model.FindBoundingBox();
}
Model.AdjustNormals(NormalType,NormalSplit);
Model.CalculateTangents();
// Don't forget the skins
OGL_SkinManager::Load();
}
void OGL_TextureOptionsBase::Load()
{
FileSpecifier File;
GLint maxTextureSize = 0;
if (GetMaxSize()) {
maxTextureSize = MIN(maxTextureSize, GetMaxSize());
}
int flags = ImageLoader_ResizeToPowersOfTwo;
if (Type >= 0 && Type < OGL_NUMBER_OF_TEXTURE_TYPES &&
Get_OGL_ConfigureData().TxtrConfigList[Type].FarFilter >
1 /* GL_LINEAR */) {
flags |= ImageLoader_LoadMipMaps;
}
if (hasS3TC) {
flags |= ImageLoader_CanUseDXTC;
}
if (Get_OGL_ConfigureData().GeForceFix) {
flags |= ImageLoader_LoadDXTC1AsDXTC3;
}
// Load the normal image with alpha channel
// Check to see if loading needs to be done;
// it does not need to be if an image is present.
if (NormalImg.IsPresent()) {
return;
}
NormalImg.Clear();
// Load the normal image if it has a filename specified for it
if (NormalColors != FileSpecifier() && NormalColors.Exists()) {
if (!NormalImg.LoadFromFile(NormalColors,ImageLoader_Colors, flags |
(NormalIsPremultiplied ?
ImageLoader_ImageIsAlreadyPremultiplied : 0),
actual_width, actual_height, maxTextureSize)) {
// A texture must have a normal colored part
return;
}
}
else
{
return;
}
// load a heightmap
if(OffsetMap != FileSpecifier() && OffsetMap.Exists()) {
if(!OffsetImg.LoadFromFile(OffsetMap, ImageLoader_Colors, flags |
(NormalIsPremultiplied ?
ImageLoader_ImageIsAlreadyPremultiplied : 0),
actual_width, actual_height, maxTextureSize)) {
return;
}
}
// Load the normal mask if it has a filename specified for it
if (NormalMask != FileSpecifier() && NormalMask.Exists()) {
NormalImg.LoadFromFile(NormalMask,ImageLoader_Opacity, flags, actual_width,
actual_height,
maxTextureSize);
}
if (maxTextureSize) {
while (NormalImg.GetWidth() > maxTextureSize || NormalImg.GetHeight() >
maxTextureSize)
{
if (!NormalImg.Minify()) {
break;
}
}
if(OffsetImg.IsPresent()) {
while (OffsetImg.GetWidth() > maxTextureSize || OffsetImg.GetHeight() >
maxTextureSize) {
if(!OffsetImg.Minify()) {
break;
}
}
}
}
// Load the glow image with alpha channel
if (!GlowImg.IsPresent()) {
GlowImg.Clear();
// Load the glow image if it has a filename specified for it
if (GlowColors != FileSpecifier() && GlowColors.Exists()) {
if (GlowImg.LoadFromFile(GlowColors,ImageLoader_Colors, flags |
(GlowIsPremultiplied ?
ImageLoader_ImageIsAlreadyPremultiplied : 0),
actual_width, actual_height, maxTextureSize)) {
// Load the glow mask if it has a
// filename specified for it; only
// loaded if an image has been loaded
// for it
if (GlowMask != FileSpecifier() && GlowMask.Exists()) {
GlowImg.LoadFromFile(GlowMask,ImageLoader_Opacity, flags,
actual_width, actual_height,
maxTextureSize);
}
}
}
}
if (GlowImg.IsPresent() && maxTextureSize) {
while (GlowImg.GetWidth() > maxTextureSize || GlowImg.GetHeight() >
maxTextureSize)
{
if (!GlowImg.Minify()) {
break;
}
}
}
// The rest of the code is made simpler by these constraints:
// that the glow texture only be present if the normal texture is also present,
// and that the normal and glow textures have the same dimensions
if (NormalImg.IsPresent()) {
int W0 = NormalImg.GetWidth();
int W1 = GlowImg.GetWidth();
int H0 = NormalImg.GetHeight();
int H1 = GlowImg.GetHeight();
if ((W1 != W0) || (H1 != H0)) {
GlowImg.Clear();
}
}
else
{
GlowImg.Clear();
}
}
