public bool LoadMapTextures()
{
foreach (Lump l in WadLoader.lumps)
{
if (l.lumpName == "TEXTURE1")
{
int p = 0;
int num = (int)(l.data[p++] | (int)l.data[p++] << 8 | (int)l.data[p++] << 16 | (int)l.data[p++] << 24);
int[] offsets = new int[num];
for (int i = 0; i < num; i++)
{
offsets[i] = (int)(l.data[p++] | (int)l.data[p++] << 8 | (int)l.data[p++] << 16 | (int)l.data[p++] << 24);
}
MapTextures.Clear();
for (int i = 0; i < num; i++)
{
p = offsets[i];
MapTexture t = new MapTexture();
t.textureName = Encoding.ASCII.GetString(new byte[]
{
l.data[p++],
l.data[p++],
l.data[p++],
l.data[p++],
l.data[p++],
l.data[p++],
l.data[p++],
l.data[p++]
}).TrimEnd('\0').ToUpper();
t.masked = (int)(l.data[p++] | (int)l.data[p++] << 8 | (int)l.data[p++] << 16 | (int)l.data[p++] << 24);
t.width = (int)(l.data[p++] | (int)l.data[p++] << 8);
t.height = (int)(l.data[p++] | (int)l.data[p++] << 8);
t.columnDirectory = (int)(l.data[p++] | (int)l.data[p++] << 8 | (int)l.data[p++] << 16 | (int)l.data[p++] << 24);
int patchCount = (int)(l.data[p++] | (int)l.data[p++] << 8);
t.patches = new MapPatch[patchCount];
for (int j = 0; j < patchCount; j++)
{
MapPatch patch = new MapPatch();
patch.originx = (short)(l.data[p++] | (short)l.data[p++] << 8);
patch.originy = (short)(l.data[p++] | (short)l.data[p++] << 8);
patch.number = (int)(l.data[p++] | (int)l.data[p++] << 8);
patch.stepdir = (int)(l.data[p++] | (int)l.data[p++] << 8);
patch.colormap = (int)(l.data[p++] | (int)l.data[p++] << 8);
t.patches[j] = patch;
}
MapTextures.Add(t);
}
return(true);
}
}
return(false);
}
void ReadWADTextures()
{
List <DrctEntry> texLumps = new List <DrctEntry>();
foreach (DrctEntry entry in newWad.directory)//Find texture's lumps
{
if (entry.name.StartsWith("TEXTURE"))
{
texLumps.Add(entry);
}
}
foreach (DrctEntry texEntry in texLumps)
{
TEXTUREx newTexture = new TEXTUREx();
int texOfs = 0;
byte[] tbytes = new byte[texEntry.size];
wadOpener.Position = texEntry.filepos;
wadOpener.Read(tbytes, 0, tbytes.Length);
//Header////
newTexture.numTextures = BitConverter.ToInt32(tbytes, 0);
for (int i = 4; i <= (4 * newTexture.numTextures); i += 4)
{
newTexture.offset.Add(BitConverter.ToInt32(tbytes, i));
}
texOfs = (newTexture.numTextures * 4) + 4; //start of maptexture_t?????
int lastPatchCount = 0;
//for every texture
foreach (int ofs in newTexture.offset)
{
MapTexture mtex = new MapTexture();
//read the info
mtex.name = new String(System.Text.Encoding.ASCII.GetChars(tbytes, ofs, 8));
mtex.masked = BitConverter.ToBoolean(tbytes, ofs + 8);
mtex.width = BitConverter.ToInt16(tbytes, ofs + 12);
mtex.height = BitConverter.ToInt16(tbytes, ofs + 14);
//mtex.columndirectory = BitConverter.ToInt32(tbytes, ofs + 16);
mtex.patchCount = BitConverter.ToInt16(tbytes, ofs + 20);
lastPatchCount = mtex.patchCount;
mtex.name = mtex.name.Replace("\0", "");
UsedImages.Add(mtex.name);
for (int a = ofs + 22; a < ofs + 22 + (10 * mtex.patchCount); a += 10)
{
MapPatch mPatch = new MapPatch();
mPatch.originx = (int)BitConverter.ToInt16(tbytes, a);
mPatch.originy = (int)BitConverter.ToInt16(tbytes, a + 2);
mPatch.patch = (int)BitConverter.ToInt16(tbytes, a + 4);
mtex.mPatch.Add(mPatch);
}
newTexture.mtex.Add(mtex); //store the info in newTexture.mtex
Color32[,] texPixels = new Color32[mtex.width, mtex.height]; //store the pixels for the texture (L->R, U->D)
bool trans = false;
foreach (MapPatch mpatch in mtex.mPatch) //for each patch in the texture
{
int width = newWad.patches[mpatch.patch].GetLength(0);
int height = newWad.patches[mpatch.patch].GetLength(1);
for (int x = 0; x < width; x++) //for each width pixel
{
for (int y = 0; y < height; y++) //for each height pixel
{
Color pixel = newWad.patches[mpatch.patch][x, (height - 1) - y];
int xofs = x + mpatch.originx;
int yofs = y + mpatch.originy;
if (pixel == Color.clear)
{
trans = true;
}
if (pixel.a > 0 && xofs >= 0 && yofs >= 0 && xofs < mtex.width && yofs < mtex.height)
{
texPixels[xofs, yofs] = pixel;
}
}
}
}
Color[] texPix = new Color[mtex.width * mtex.height];
Material newMat;
if (!trans)
{
newMat = new Material(DoomShader);
}
else
{
newMat = new Material(DoomShaderTransparent);
}
for (int i = 0; i < mtex.height; i++)
{
for (int j = 0; j < mtex.width; j++)
{
// Debug.Log(i * mtex.height + j);
texPix[i * mtex.width + j] = texPixels[j, i]; //collapse the 2Darry "texPixels" to a 1D array "texPix"
}
}
Texture2D newTex = new Texture2D(mtex.width, mtex.height, TextureFormat.RGBA32, false);
newTex.filterMode = FilterMode.Point;
newTex.SetPixels(texPix);
newTex.Apply();
newTex.name = mtex.name;
newMat.mainTexture = newTex;
newWad.textures.Add(newTex.name, newMat);
}
}
}
private void viewMapFile(string mapName)
{
MapFileParser p = new MapFileParser();
try
{
if (p.loadMapFile(mapName))
{
MessageBox.Show("Failed to load .map file '" + mapName + "'");
return;
}
}
catch (System.IO.DirectoryNotFoundException ex)
{
MessageBox.Show("Failed to load .map file '" + mapName + "' - directory not found exception.");
return;
}
map = p.getMapFile();
map.setTreeView(treeView1);
/*
* MapFileWriter w = new MapFileWriter();
* w.writeMapFile(map, mapName + "_textExport.map");
* */
treeView1.BeginUpdate();
treeView1.Nodes.Clear();
for (int i = 0; i < map.getNumEntities(); i++)
{
MapEntity entity = map.getEntity(i);
TreeNode nodeEntity = new TreeNode("Entity " + i + " (" + entity.getClassName() + ")");
nodeEntity.Tag = entity;
entity.setTreeViewNode(nodeEntity);
TreeNode nodeKeyValues = new TreeNode("Variables");
KeyValuesList epairs = entity.getKeyValues();
nodeKeyValues.Tag = epairs;
for (int j = 0; j < epairs.size(); j++)
{
TreeNode nodeKey = new TreeNode(epairs.getPairKey(j));
TreeNode nodeValue = new TreeNode(epairs.getPairValue(j));
// save the node so epairs can automatically update GUI
epairs.setPairTreeNode(j, nodeKey);
nodeKey.Tag = epairs;
nodeValue.Tag = epairs;
nodeKey.Nodes.Add(nodeValue);
nodeKeyValues.Nodes.Add(nodeKey);
}
nodeEntity.Nodes.Add(nodeKeyValues);
if (entity.getNumBrushes() != 0 || entity.getNumPatches() != 0)
{
TreeNode nodeGeometry = new TreeNode("Geometry");
if (entity.getNumBrushes() != 0)
{
TreeNode nodeBrushes = new TreeNode("Brushes");
for (int j = 0; j < entity.getNumBrushes(); j++)
{
MapBrushBase brBase = entity.getBrush(j);
if (brBase.isOldBrush())
{
MapBrushOld br = (MapBrushOld)brBase;
TreeNode nodeBrush = new TreeNode("Brush (old format) " + j);
nodeBrush.Tag = br;
for (int k = 0; k < br.getNumSides(); k++)
{
MapBrushSideOld side = br.getSide(k);
TreeNode nodeSide = new TreeNode("Side " + k);
// plane points
TreeNode nodePlanePoints = new TreeNode("Plane points");
nodePlanePoints.Nodes.Add(side.getPlanePointA().ToStringBraced()
+ " " + side.getPlanePointB().ToStringBraced()
+ " " + side.getPlanePointB().ToStringBraced());
nodeSide.Nodes.Add(nodePlanePoints);
// material
TreeNode nodeMaterial = new TreeNode("Material");
nodeMaterial.Nodes.Add(side.getMatName());
nodeSide.Nodes.Add(nodeMaterial);
// tex scale
TreeNode nodeTexScale = new TreeNode("TexScale");
nodeTexScale.Nodes.Add(side.getTexScale().ToString());
nodeSide.Nodes.Add(nodeTexScale);
// tex shift
TreeNode nodeTexShift = new TreeNode("TexShift");
nodeTexShift.Nodes.Add(side.getTexShift().ToString());
nodeSide.Nodes.Add(nodeTexShift);
// tex rotation
TreeNode nodeTexRotation = new TreeNode("TexRotation");
nodeTexRotation.Nodes.Add(side.getTexRotation().ToString());
nodeSide.Nodes.Add(nodeTexRotation);
// contents (eg. detail)
TreeNode nodeContentFlags = new TreeNode("ContentFlags");
nodeContentFlags.Nodes.Add(side.getContentFlags().ToString());
nodeSide.Nodes.Add(nodeContentFlags);
nodeBrush.Nodes.Add(nodeSide);
}
nodeBrushes.Nodes.Add(nodeBrush);
}
else
{
MapBrushDef3 br = (MapBrushDef3)brBase;
TreeNode nodeBrush = new TreeNode("Brush (Def3) " + j);
nodeBrush.Tag = br;
for (int k = 0; k < br.getNumSides(); k++)
{
MapBrushSide4 side = br.getSide(k);
TreeNode nodeSide = new TreeNode("Side " + k);
// plane points
TreeNode nodePlanePoints = new TreeNode("Plane");
nodePlanePoints.Nodes.Add(side.getPlane().ToString());
nodeSide.Nodes.Add(nodePlanePoints);
// material
TreeNode nodeMaterial = new TreeNode("Material");
nodeMaterial.Nodes.Add(side.getMatName());
nodeSide.Nodes.Add(nodeMaterial);
// tex matrix
TreeNode nodeTexAxis0 = new TreeNode("TexAxis0");
nodeTexAxis0.Nodes.Add(side.getTextureAxis0().ToString());
nodeSide.Nodes.Add(nodeTexAxis0);
TreeNode nodeTexAxis1 = new TreeNode("TexAxis1");
nodeTexAxis1.Nodes.Add(side.getTextureAxis1().ToString());
nodeSide.Nodes.Add(nodeTexAxis1);
nodeBrush.Nodes.Add(nodeSide);
}
nodeBrushes.Nodes.Add(nodeBrush);
}
}
nodeGeometry.Nodes.Add(nodeBrushes);
}
if (entity.getNumPatches() != 0)
{
TreeNode nodePatches = new TreeNode("Patches");
for (int j = 0; j < entity.getNumPatches(); j++)
{
MapPatch patch = entity.getPatch(j);
TreeNode nodePatch = new TreeNode("Patch " + j);
// material
TreeNode nodeMaterial = new TreeNode("Material");
nodeMaterial.Nodes.Add(patch.getMatName());
nodePatch.Nodes.Add(nodeMaterial);
// sizes
TreeNode nodeSizes = new TreeNode("Size");
nodeSizes.Nodes.Add(patch.getSizeW().ToString() + " " + patch.getSizeH().ToString());
nodePatch.Nodes.Add(nodeSizes);
// verts
TreeNode nodeVerts = new TreeNode("Verts");
for (int k = 0; k < patch.getSizeH(); k++)
{
TreeNode nodeRowK = new TreeNode("Row " + k);
for (int l = 0; l < patch.getSizeW(); l++)
{
TreeNode nodeVertex = new TreeNode("Vertex " + l + " (abs " + k + "/" + l + ")");
nodeVertex.Nodes.Add(patch.getVertex(l, k).ToString());
nodeRowK.Nodes.Add(nodeVertex);
}
nodeVerts.Nodes.Add(nodeRowK);
}
nodePatch.Nodes.Add(nodeVerts);
nodePatches.Nodes.Add(nodePatch);
}
nodeGeometry.Nodes.Add(nodePatches);
}
nodeEntity.Nodes.Add(nodeGeometry);
}
treeView1.Nodes.Add(nodeEntity);
treeView1.EndUpdate();
}
}
