private void MouseMoveControl(object sender, MouseEventArgs e)
{
if (mouseMode)
{
SharpRenderer.Camera.AddYaw(MathUtil.DegreesToRadians(Cursor.Position.X - MouseCenter.X) / 4);
SharpRenderer.Camera.AddPitch(MathUtil.DegreesToRadians(Cursor.Position.Y - MouseCenter.Y) / 4);
Cursor.Position = MouseCenter;
}
else
{
if (e.Button == MouseButtons.Middle)
{
SharpRenderer.Camera.AddYaw(MathUtil.DegreesToRadians(e.X - oldMouseX));
SharpRenderer.Camera.AddPitch(MathUtil.DegreesToRadians(e.Y - oldMouseY));
}
if (e.Button == MouseButtons.Right)
{
SharpRenderer.Camera.AddPositionSideways(e.X - oldMouseX);
SharpRenderer.Camera.AddPositionUp(e.Y - oldMouseY);
}
}
oldMouseX = e.X;
oldMouseY = e.Y;
if (loopNotStarted)
{
loopNotStarted = false;
SharpRenderer.RunMainLoop(renderPanel);
}
}
public void RenderShadowCollisionModel(SharpRenderer renderer, List <LevelEditor.Chunk> chunkList)
{
if (renderByChunk)
{
DetermineVisibleChunks(renderer, chunkList);
}
renderer.Device.SetDefaultBlendState();
renderer.Device.SetFillModeDefault();
renderer.Device.SetCullModeDefault();
renderer.Device.ApplyRasterState();
renderer.Device.UpdateAllStates();
renderer.Device.UpdateData(renderer.defaultBuffer, renderer.viewProjection);
renderer.Device.DeviceContext.VertexShader.SetConstantBuffer(0, renderer.defaultBuffer);
renderer.defaultShader.Apply();
for (int j = 0; j < ShadowColBSPList.Count; j++)
{
if (renderByChunk & !VisibleChunks.Contains(ShadowColBSPList[j].ChunkNumber))
{
continue;
}
ShadowColBSPList[j].Render(renderer.Device);
}
}
private void RenderOpaque(SharpRenderer renderer)
{
renderer.Device.SetDefaultBlendState();
renderer.Device.SetDefaultDepthState();
renderer.Device.SetCullModeDefault();
renderer.Device.UpdateData(renderer.defaultBuffer, renderer.viewProjection);
renderer.Device.DeviceContext.VertexShader.SetConstantBuffer(0, renderer.defaultBuffer);
for (int j = 0; j < BSPList.Count; j++)
{
if ((renderByChunk && !VisibleChunks.Contains(BSPList[j].ChunkNumber)) ||
(BSPList[j].ChunkName == "A" || BSPList[j].ChunkName == "P" || BSPList[j].ChunkName == "K"))
{
continue;
}
if (BSPList[j].isNoCulling)
{
renderer.Device.SetCullModeNone();
}
else
{
renderer.Device.SetCullModeDefault();
}
renderer.Device.ApplyRasterState();
renderer.Device.UpdateAllStates();
BSPList[j].Render(renderer.Device);
}
}
public static void ClearTextures(SharpRenderer renderer, BSPRenderer bspRenderer)
{
OpenTXDfiles.Clear();
OpenTextureFolders.Clear();
DisposeTextures();
Textures.Clear();
ReapplyTextures(renderer, bspRenderer);
}
private void SetShadowBSPList(SharpRenderer renderer, List <Archive> OpenShadowONEFiles)
{
Dispose();
BSPList = new List <RenderWareModelFile>();
ShadowColBSPList = new List <RenderWareModelFile>();
ReadFileMethods.isShadow = true;
foreach (Archive f in OpenShadowONEFiles)
{
foreach (ArchiveFile file in f.Files)
{
string ChunkName = Path.GetFileNameWithoutExtension(file.Name);
if (ChunkName.Contains("COLI"))
{
ReadFileMethods.isCollision = true;
RenderWareModelFile TempBSPFile = new RenderWareModelFile(file.Name);
foreach (string s in ChunkName.Split('_'))
{
try
{
TempBSPFile.ChunkNumber = Convert.ToByte(s);
break;
}
catch { TempBSPFile.ChunkNumber = -1; }
}
TempBSPFile.isShadowCollision = true;
try
{
byte[] data = file.DecompressThis();
TempBSPFile.SetForRendering(renderer.Device, ReadFileMethods.ReadRenderWareFile(data), data);
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show("Error on opening " + file.Name + ": " + e.Message);
}
ShadowColBSPList.Add(TempBSPFile);
ReadFileMethods.isCollision = false;
}
else
{
RenderWareModelFile TempBSPFile = new RenderWareModelFile(file.Name);
TempBSPFile.SetChunkNumberAndName();
byte[] data = file.DecompressThis();
TempBSPFile.SetForRendering(renderer.Device, ReadFileMethods.ReadRenderWareFile(data), data);
BSPList.Add(TempBSPFile);
}
}
}
}
private void renderPanel_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
SharpRenderer.ScreenClicked(new Rectangle(
renderPanel.ClientRectangle.X,
renderPanel.ClientRectangle.Y,
renderPanel.ClientRectangle.Width,
renderPanel.ClientRectangle.Height), e.X, e.Y);
}
}
// Rendering functions
public void RenderLevelModel(SharpRenderer renderer, List <LevelEditor.Chunk> chunkList)
{
if (renderByChunk)
{
DetermineVisibleChunks(renderer, chunkList);
}
renderer.Device.SetFillModeDefault();
renderer.defaultShader.Apply();
RenderOpaque(renderer);
RenderAlpha(renderer);
}
public static void ReapplyTextures(SharpRenderer renderer, BSPRenderer bspRenderer)
{
List <RenderWareModelFile> models = new List <RenderWareModelFile>();
models.AddRange(bspRenderer.BSPList);
models.AddRange(bspRenderer.ShadowColBSPList);
models.AddRange(renderer.dffRenderer.DFFModels.Values);
foreach (RenderWareModelFile m in models)
{
foreach (SharpMesh mesh in m.meshList)
{
foreach (SharpSubSet sub in mesh.SubSets)
{
if (Textures.ContainsKey(sub.DiffuseMapName))
{
if (sub.DiffuseMap != Textures[sub.DiffuseMapName])
{
if (sub.DiffuseMap != null)
{
if (!sub.DiffuseMap.IsDisposed)
{
if (sub.DiffuseMap != SharpRenderer.whiteDefault)
{
sub.DiffuseMap.Dispose();
}
}
}
sub.DiffuseMap = Textures[sub.DiffuseMapName];
}
}
else
{
if (sub.DiffuseMap != null)
{
if (!sub.DiffuseMap.IsDisposed)
{
if (sub.DiffuseMap != SharpRenderer.whiteDefault)
{
sub.DiffuseMap.Dispose();
}
}
}
sub.DiffuseMap = SharpRenderer.whiteDefault;
}
}
}
}
}
public static void LoadTexturesFromFolder(string folderName, SharpRenderer renderer, BSPRenderer bspRenderer)
{
OpenTextureFolders.Add(folderName);
foreach (string i in Directory.GetFiles(folderName))
{
if (Path.GetExtension(i).ToLower().Equals(".png"))
{
AddTexturePNG(i, renderer);
}
}
ReapplyTextures(renderer, bspRenderer);
}
public void DetermineVisibleChunks(SharpRenderer renderer, List <LevelEditor.Chunk> chunkList)
{
VisibleChunks.Clear();
VisibleChunks.Add(-1);
Vector3 cameraPos = renderer.Camera.GetPosition();
foreach (var c in chunkList)
{
if ((cameraPos.X > c.Min.X) && (cameraPos.Y > c.Min.Y) && (cameraPos.Z > c.Min.Z) &
(cameraPos.X < c.Max.X) && (cameraPos.Y < c.Max.Y) && (cameraPos.Z < c.Max.Z))
{
VisibleChunks.Add(c.number);
}
}
}
public static void LoadTexturesFromTXD(RWSection[] txdFile, SharpRenderer renderer, BSPRenderer bspRenderer)
{
foreach (RWSection rw in txdFile)
{
if (rw is TextureDictionary_0016 td)
{
foreach (TextureNative_0015 tn in td.textureNativeList)
{
AddTextureNative(tn.textureNativeStruct, renderer);
}
}
}
ReapplyTextures(renderer, bspRenderer);
}
private void ToggleShowObjects()
{
if (showObjectsGToolStripMenuItem.CheckState == CheckState.Checked)
{
showObjectsGToolStripMenuItem.CheckState = CheckState.Unchecked;
}
else if (showObjectsGToolStripMenuItem.CheckState == CheckState.Indeterminate)
{
showObjectsGToolStripMenuItem.CheckState = CheckState.Checked;
}
else if (showObjectsGToolStripMenuItem.CheckState == CheckState.Unchecked)
{
showObjectsGToolStripMenuItem.CheckState = CheckState.Indeterminate;
}
SharpRenderer.SetShowObjects(showObjectsGToolStripMenuItem.CheckState);
}
private static void AddTextureNative(TextureNativeStruct_0001 tnStruct, SharpRenderer renderer)
{
if (Textures.ContainsKey(tnStruct.textureName))
{
if (Textures[tnStruct.textureName] != null)
{
if (!Textures[tnStruct.textureName].IsDisposed)
{
Textures[tnStruct.textureName].Dispose();
}
}
Textures[tnStruct.textureName] = renderer.Device.LoadTextureFromRenderWareNative(tnStruct);
}
else
{
Textures.Add(tnStruct.textureName, renderer.Device.LoadTextureFromRenderWareNative(tnStruct));
}
}
public static void SetupTextureDisplay(byte[] txdFile, SharpRenderer renderer, BSPRenderer bspRenderer)
{
if (!Directory.Exists(tempGcTxdsDir))
{
Directory.CreateDirectory(tempGcTxdsDir);
}
if (!Directory.Exists(tempPcTxdsDir))
{
Directory.CreateDirectory(tempPcTxdsDir);
}
File.WriteAllBytes(pathToGcTXD, txdFile);
PerformTXDConversionExternal();
LoadTexturesFromTXD(pathToPcTXD, renderer, bspRenderer);
ReapplyTextures(renderer, bspRenderer);
File.Delete(pathToGcTXD);
File.Delete(pathToPcTXD);
}
private static void AddTexturePNG(string path, SharpRenderer renderer)
{
string textureName = Path.GetFileNameWithoutExtension(path);
if (Textures.ContainsKey(textureName))
{
if (Textures[textureName] != null)
{
if (!Textures[textureName].IsDisposed)
{
Textures[textureName].Dispose();
}
}
Textures[textureName] = renderer.Device.LoadTextureFromFile(path);
}
else
{
Textures.Add(textureName, renderer.Device.LoadTextureFromFile(path));
}
}
public void LoadShadowLevelFolder(SharpRenderer renderer, string Folder, LevelEditor.LevelEditor levelEditor)
{
List <Archive> ShadowONEFiles = new List <Archive>();
currentShadowFolderNamePrefix = Path.GetFileNameWithoutExtension(Folder);
foreach (string fileName in Directory.GetFiles(Folder))
{
if (Path.GetExtension(fileName).ToLower() == ".one")
{
if (!(fileName.Contains("dat") ||
fileName.Contains("fx") ||
fileName.Contains("gdt") ||
fileName.Contains("tex")))
{
byte[] oneDataBytes = File.ReadAllBytes(fileName);
ShadowONEFiles.Add(Archive.FromONEFile(ref oneDataBytes));
}
else if (fileName.Contains("dat"))
{
levelEditor.initVisibilityEditor(true, fileName);
levelEditor.shadowSplineEditor.Init(fileName);
}
else if (fileName.Contains("fx"))
{
// OpenShadowFXONE = new HeroesONEFile(fileName);
}
else if (fileName.Contains("gdt"))
{
Program.MainForm.renderer.dffRenderer.AddDFFFiles(new string[] { fileName });
}
else if (fileName.Contains("tex"))
{
TextureManager.LoadTexturesFromTXD(fileName, renderer, this);
}
}
}
SetShadowBSPList(renderer, ShadowONEFiles);
}
public static void LoadTexturesFromTXD(string filePath, SharpRenderer renderer, BSPRenderer bspRenderer)
{
if (!Path.GetFileName(filePath).Equals("temp.txd"))
{
OpenTXDfiles.Add(filePath);
}
try
{
if (Path.GetExtension(filePath).ToLower().Equals(".one"))
{
byte[] oneFile = File.ReadAllBytes(filePath);
Archive archive = Archive.FromONEFile(ref oneFile);
foreach (ArchiveFile archiveFile in archive.Files)
{
if (Path.GetExtension(archiveFile.Name).ToLower().Equals(".txd"))
{
SetupTextureDisplay(archiveFile.DecompressThis(), renderer, bspRenderer);
}
}
}
else if (Path.GetExtension(filePath).ToLower().Equals(".txd"))
{
LoadTexturesFromTXD(File.ReadAllBytes(filePath), renderer, bspRenderer);
}
else
{
throw new InvalidDataException(filePath);
}
}
catch (Exception ex)
{
MessageBox.Show("Error opening " + filePath + ": " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
OpenTXDfiles.Remove(filePath);
}
}
private void ToggleStartPos()
{
startPosYToolStripMenuItem.Checked = !startPosYToolStripMenuItem.Checked;
SharpRenderer.SetShowStartPos(startPosYToolStripMenuItem.Checked);
}
public static void LoadTexturesFromTXD(byte[] txdData, SharpRenderer renderer, BSPRenderer bspRenderer)
{
LoadTexturesFromTXD(ReadFileMethods.ReadRenderWareFile(txdData), renderer, bspRenderer);
}
private void ToggleShowCameras()
{
camerasVToolStripMenuItem.Checked = !camerasVToolStripMenuItem.Checked;
SharpRenderer.SetShowCameras(camerasVToolStripMenuItem.Checked);
}
private void ToggleShowQuadtree()
{
showQuadtreeTToolStripMenuItem.Checked = !showQuadtreeTToolStripMenuItem.Checked;
SharpRenderer.SetShowQuadtree(showQuadtreeTToolStripMenuItem.Checked);
}
private void ToggleShowCollision()
{
showCollisionXToolStripMenuItem.Checked = !showCollisionXToolStripMenuItem.Checked;
SharpRenderer.SetShowCollision(showCollisionXToolStripMenuItem.Checked);
}
private void ToggleChunkBoxes()
{
chunkBoxesBToolStripMenuItem.Checked = !chunkBoxesBToolStripMenuItem.Checked;
SharpRenderer.SetChunkBoxes(chunkBoxesBToolStripMenuItem.Checked);
}
private void ToggleSplines()
{
splinesUToolStripMenuItem.Checked = !splinesUToolStripMenuItem.Checked;
SharpRenderer.SetSplines(splinesUToolStripMenuItem.Checked);
}
private void camerasToolStripMenuItem_Click(object sender, EventArgs e)
{
SharpRenderer.SetMouseModeObjects(false);
camerasToolStripMenuItem.Checked = true;
objectsToolStripMenuItem.Checked = false;
}