public EditorPanel(PyramidPanic game, EditorScene editorScene, Vector2 location)
{
this.game = game;
this.editorScene = editorScene;
this.location = location;
this.LoadContent();
}
private void SetScene(GameScene scene)
{
this.scene = scene;
if (scene.kind == Scene.LOAD)
{
load = (LoadScene)scene;
}
else if (scene.kind == Scene.INTRO)
{
intro = (IntroScene)scene;
}
else if (scene.kind == Scene.ACTION)
{
action = (ActionScene)scene;
}
else if (scene.kind == Scene.EDITOR)
{
editor = (EditorScene)scene;
}
}
public override void Draw(GL_ControlModern control, Pass pass, EditorScene editorScene)
{
CheckBuffers();
if (!Runtime.OpenTKInitialized)
{
return;
}
control.CurrentShader = defaultShaderProgram;
defaultShaderProgram.EnableVertexAttributes();
SetRenderSettings(defaultShaderProgram);
Matrix4 previewScale = Utils.TransformValues(Vector3.Zero, Vector3.Zero, Runtime.previewScale);
Matrix4 camMat = previewScale * control.mtxCam * control.mtxProj;
defaultShaderProgram.SetMatrix4x4("previewScale", ref previewScale);
GL.Disable(EnableCap.CullFace);
GL.Uniform3(defaultShaderProgram["difLightDirection"], Vector3.TransformNormal(new Vector3(0f, 0f, -1f), camMat.Inverted()).Normalized());
GL.Uniform3(defaultShaderProgram["difLightColor"], new Vector3(1));
GL.Uniform3(defaultShaderProgram["ambLightColor"], new Vector3(1));
defaultShaderProgram.EnableVertexAttributes();
SetRenderSettings(defaultShaderProgram);
foreach (KCLModel mdl in models)
{
DrawModel(mdl, defaultShaderProgram);
}
defaultShaderProgram.DisableVertexAttributes();
GL.UseProgram(0);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
Scene = new EditorScene();
Scene.RenderDistance = 10000000;
Scene.ObjectsMoved += OnObjectsMoved;
LoadBaseDrawables();
WalkaroundCamera.CameraSpeed = 40;
GL_EditorFramework.EditorDrawables.Path.CubeScale = 20;
GL_EditorFramework.EditorDrawables.Path.ControlCubeScale = 15;
gl_Control.CameraDistance = 30;
gl_Control.AllowDrop = true;
if (gl_Control is GL_ControlModern)
{
GL_EditorFramework.Renderers.ColorBlockRenderer.Initialize((GL_ControlModern)gl_Control);
}
loaded = true;
}
private void OnPlay()
{
if (!_previewScene)
{
_previewScene = new EditorScene();
}
if (!_previewSource)
{
_previewSource = new AudioSource
{
Parent = _previewScene,
Clip = _asset,
};
}
if (_previewSource.State == AudioSource.States.Playing)
{
_previewSource.Stop();
}
else
{
_previewSource.Play();
}
UpdateToolstrip();
}
/// <summary>
/// Overridden NewScene function
/// </summary>
/// <param name="relFileName"></param>
/// <param name="bPlainEmpty"></param>
/// <returns></returns>
public override bool NewScene(string relFileName, bool bPlainEmpty)
{
object[] parameters = { this, relFileName };
EditorScene editorScene = EditorManager.SceneFactory.CreateInstance(parameters) as EditorScene;
if (editorScene == null)
{
EditorManager.ShowMessageBox("Scene must be derived from class 'EditorScene'", "Failed to create scene", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
EditorManager.ActiveView.SetCameraPosition(editorScene.Settings.CameraPosition);
EditorManager.ActiveView.SetCameraRotation(editorScene.Settings.CameraAngles);
_scene = editorScene;
// save the scene (empty) such that all layers can be safely saved
editorScene.SaveAs(relFileName);
if (!bPlainEmpty)
{
V3DLayer MainLayer = new V3DLayer("Main layer");
editorScene.AddLayer(MainLayer, true, false);
// mark the layer as dirty, to ensure that it will be saved now
MainLayer.Dirty = true;
}
// this will fire an event that is often used to set things up, so only now the scene will be set up completely
Scene = editorScene; // set it afterwards so the OnSceneChanged callback has the correct name
// save the scene again, now with all layers, because NOW all scene elements will be really setup
editorScene.SaveAs(relFileName);
return(true);
}
// 登记所有的场景处理器
private static void RegisterScene()
{
SceneM.RegisterScene(EditorScene.GetSceneName(), new EditorScene());
}
public override void Draw(GL_ControlModern control, Pass pass, EditorScene editorScene)
{
CheckBuffers();
if (!Runtime.OpenTKInitialized || !Runtime.renderBones || solidColorShaderProgram == null)
{
return;
}
GL.UseProgram(0);
GL.Disable(EnableCap.CullFace);
if (Runtime.boneXrayDisplay)
{
GL.Disable(EnableCap.DepthTest);
}
control.CurrentShader = solidColorShaderProgram;
Matrix4 previewScale = Utils.TransformValues(Vector3.Zero, Vector3.Zero, Runtime.previewScale);
solidColorShaderProgram.EnableVertexAttributes();
solidColorShaderProgram.SetMatrix4x4("rotation", ref prismRotation);
solidColorShaderProgram.SetMatrix4x4("previewScale", ref previewScale);
foreach (STBone bn in bones)
{
if (!bn.Checked)
{
continue;
}
solidColorShaderProgram.SetVector4("boneColor", ColorUtility.ToVector4(boneColor));
solidColorShaderProgram.SetFloat("scale", Runtime.bonePointSize);
Matrix4 transform = bn.Transform;
solidColorShaderProgram.SetMatrix4x4("bone", ref transform);
solidColorShaderProgram.SetInt("hasParent", bn.parentIndex != -1 ? 1 : 0);
if (bn.parentIndex != -1)
{
var transformParent = ((STBone)bn.Parent).Transform;
solidColorShaderProgram.SetMatrix4x4("parent", ref transformParent);
}
Draw(solidColorShaderProgram);
if (Runtime.SelectedBoneIndex == bn.GetIndex())
{
solidColorShaderProgram.SetVector4("boneColor", ColorUtility.ToVector4(selectedBoneColor));
}
solidColorShaderProgram.SetInt("hasParent", 0);
Draw(solidColorShaderProgram);
}
solidColorShaderProgram.DisableVertexAttributes();
GL.UseProgram(0);
GL.Enable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
}
public void UpdateObjects()
{
OnPropertyChanged(nameof(EditorScene));
EditorScene.Render();
}
public void SetEditorCanvas(Canvas editorCanvas)
{
EditorScene.SetCanvas(editorCanvas);
OnPropertyChanged(nameof(UpdateSceneAction));
UpdateObjects();
}
/// <summary>
/// Exports all found scene files
/// </summary>
private void DoExport()
{
// Enter the testing mode (since we don't want any user dialogs etc.)
TestManager.IsRunning = true;
while (_scenesToProcess.Count > 0 && _state != State_e.Cancelling)
{
// Get one scene from the queue
_currentScene = _scenesToProcess[0];
_scenesToProcess.RemoveAt(0);
textBoxLog.Text += string.Format("Processing {0}: ", _currentScene);
// Load the scene
TestManager.Helpers.OpenSceneFromFile(_currentScene);
TestManager.Helpers.ProcessEvents();
// Force the folder type to version controlled, since we didn't have a chance to when loading the scene
EditorManager.Project.FolderType = IProject.FolderType_e.RCS;
EditorManager.Project.UpdateRCSStatus(true);
TestManager.Helpers.ProcessEvents();
// Actual export unless cancel has been clicked while loading
if (_state != State_e.Cancelling)
{
// Check if the exported scene file name is correct
string exportedSceneFile = Path.GetFileName(EditorManager.Scene.CurrentExportProfile.ExportPath);
string defaultExportName = Path.GetFileName(Path.ChangeExtension(_currentScene, CSharpFramework.Scene.SceneExportProfile.FILE_EXTENSION_EXPORT));
bool showExportDialog = false;
if (exportedSceneFile != defaultExportName)
{
textBoxLog.Text += string.Format("\r\nScene name mismatch: {0} instead of {1}: ", exportedSceneFile, defaultExportName);
if (radioMismatch_Dialog.Checked)
{
showExportDialog = true;
}
else if (radioMismatch_Revert.Checked)
{
string subDir = Path.GetDirectoryName(EditorManager.Scene.CurrentExportProfile.ExportPath);
EditorManager.Scene.CurrentExportProfile.ExportPath = Path.Combine(subDir, defaultExportName);
textBoxLog.Text += string.Format("Reverted.\r\n");
}
else
{
textBoxLog.Text += string.Format("Ignoring.\r\n");
}
}
EditorScene scene = EditorManager.Scene as EditorScene;
if (showExportDialog)
{
// Open export dialog
using (ExportDialog dlg = new ExportDialog())
{
scene.CurrentExportProfile.ExportedLayersFromScene(); // retrieve current status
dlg.Settings = scene.CurrentExportProfile; // clones the settings
dlg.AutoSaveExportProfile = scene.Settings.AutoSaveExportProfile;
// Show dialog
if (dlg.ShowDialog() != DialogResult.OK)
{
continue;
}
// Get back settings
scene.CurrentExportProfile = dlg.Settings;
scene.Settings.ExportProfileName = scene.CurrentExportProfile.ProfileName;
scene.Settings.AutoSaveExportProfile = dlg.AutoSaveExportProfile;
}
}
// Always export all zones
foreach (Zone zone in EditorManager.Scene.Zones)
{
zone.Export = true;
}
if (checkBoxMoveToCamera.Checked)
{
// TODO: Move camera to a sensible position
}
EditorManager.Progress.Percentage = 0;
// Export all profiles
List <string> assetProfiles = new List <string>();
foreach (IProfileManager.Profile profile in EditorManager.ProfileManager.GetProfiles())
{
assetProfiles.Add(profile.ToString());
}
// Export the scene
EditorManager.GUI.UIUpdateLock++;
EditorManager.Scene.ExportScene(null, assetProfiles);
EditorManager.GUI.UIUpdateLock--;
if (showExportDialog)
{
textBoxLog.Text += string.Format("Manually set to {0}.\r\n", Path.GetFileName(EditorManager.Scene.CurrentExportProfile.ExportPath));
}
textBoxLog.Text += string.Format("Export done. ");
TestManager.Helpers.ProcessEvents();
// Resave scene
if (checkBoxResaveScene.Checked)
{
EditorManager.Scene.Save();
textBoxLog.Text += string.Format("Scene file resaved. ");
TestManager.Helpers.ProcessEvents();
}
textBoxLog.Text += string.Format("\r\n");
}
// Close the project
TestManager.Helpers.CloseActiveProject();
TestManager.Helpers.ProcessEvents();
_scenesProcessed++;
}
if (State == State_e.Cancelling)
{
textBoxLog.Text += string.Format("\r\nAborted.\r\n");
}
// Reset state
_currentScene = null;
State = State_e.None;
EditorManager.Progress.StatusString = "";
EditorManager.Progress.Percentage = 0;
EditorManager.Progress.ProgressDialogEnabled = true;
// Go back to normal operation mode
TestManager.IsRunning = false;
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
EditableObject obj;
#region Create scene and add objects to it
scene = new EditorScene();
scene.objects.Add(obj = new ExampleObject(new Vector3(0, -4, 0)));
List <PathPoint> pathPoints = new List <PathPoint>
{
new PathPoint(
new Vector3(0, 0, 0),
new Vector3(0, 0, 0),
new Vector3(2, 0, 0)
),
new PathPoint(
new Vector3(8, 4, 2),
new Vector3(-4, 0, 4),
new Vector3(4, 0, -4)
),
new PathPoint(
new Vector3(4, 2, -6),
new Vector3(0, 0, 0),
new Vector3(0, 0, 0)
)
};
scene.objects.Add(obj = new Path(pathPoints));
for (int i = 0; i < 20; i++)
{
pathPoints = new List <PathPoint>
{
new PathPoint(
new Vector3(-3, 6 + i * 2, 0),
new Vector3(0, 0, -1.75f),
new Vector3(0, 0, 1.75f)
),
new PathPoint(
new Vector3(0, 6 + i * 2, 3),
new Vector3(-1.75f, 0, 0),
new Vector3(1.75f, 0, 0)
),
new PathPoint(
new Vector3(3, 6 + i * 2, 0),
new Vector3(0, 0, 1.75f),
new Vector3(0, 0, -1.75f)
),
new PathPoint(
new Vector3(0, 6 + i * 2, -3),
new Vector3(1.75f, 0, 0),
new Vector3(-1.75f, 0, 0)
)
};
scene.objects.Add(obj = new Path(pathPoints)
{
Closed = true
});
}
for (int i = 5; i < 2000; i++)
{
scene.objects.Add(obj = new TransformableObject(new Vector3(i, 0, 0), Vector3.Zero, Vector3.One));
}
#endregion
//setup the gl controls
gL_Control.MainDrawable = scene;
gL_Control.ActiveCamera = new GL_EditorFramework.StandardCameras.InspectCamera(1f);
gL_ControlLegacy1.MainDrawable = new SingleObject(new Vector3());
gL_Control.CameraDistance = 20;
//add event handlers to scene and gl control
scene.SelectionChanged += Scene_SelectionChanged;
scene.ObjectsMoved += Scene_ObjectsMoved;
scene.ListChanged += Scene_ListChanged;
scene.ListEntered += Scene_ListEntered;
scene.ListInvalidated += Scene_ListInvalidated;
gL_Control.KeyDown += GL_ControlModern1_KeyDown;
//add categories to sceneListView (in this case 15 references to the same list,
//which should never be done and only serves for demonstration purposes)
for (int i = 0; i < 15; i++)
{
sceneListView1.RootLists.Add("Test" + i, scene.objects);
}
sceneListView1.UpdateComboBoxItems();
//link the scenes selected objs to sceneListView
sceneListView1.SelectedItems = scene.SelectedObjects;
//set current category (highly recommended to do once all categories are added
sceneListView1.SetRootList("Test0");
//add event handlers to sceneListView
sceneListView1.SelectionChanged += SceneListView1_SelectionChanged;
sceneListView1.ItemsMoved += SceneListView1_ItemsMoved;
sceneListView1.ListExited += SceneListView1_ListExited;
}
protected override void Initialize()
{
base.Initialize();
scene = new EditorScene();
}
/// <summary>
/// 资源载入入口
/// </summary>
//private AsyncOperation async;
public override IEnumerator Load()
{
async = SceneManager.LoadSceneAsync(EditorScene.GetSceneName());
return(null);
}
public override void Draw(GL_ControlModern control, Pass pass, EditorScene editorScene)
{
if (!Runtime.OpenTKInitialized || pass == Pass.TRANSPARENT)
{
return;
}
bool buffersWereInitialized = ibo_elements != 0 && vbo_position != 0;
if (!buffersWereInitialized)
{
GenerateBuffers();
}
Hovered = (editorScene.hovered == this);
if (Hovered == true)
{
throw new Exception("model selected");
}
ShaderProgram shader = defaultShaderProgram;
if (Runtime.EnablePBR)
{
shader = pbrShaderProgram;
}
if (models.Count > 0)
{
if (models[0].shapes.Count > 0)
{
if (models[0].shapes[0].GetMaterial().shaderassign.ShaderModel == "uking_mat")
{
shader = BotwShaderProgram;
}
}
}
if (Runtime.viewportShading != Runtime.ViewportShading.Default)
{
shader = debugShaderProgram;
}
control.CurrentShader = shader;
control.UpdateModelMatrix(ModelTransform);
Matrix4 previewScale = Utils.TransformValues(Vector3.Zero, Vector3.Zero, Runtime.previewScale);
shader.SetMatrix4x4("previewScale", ref previewScale);
Matrix4 camMat = previewScale * control.mtxCam * control.mtxProj;
Matrix4 sphereMatrix = camMat;
sphereMatrix.Invert();
sphereMatrix.Transpose();
shader.SetMatrix4x4("sphereMatrix", ref sphereMatrix);
SetRenderSettings(shader);
Color pickingColor = control.nextPickingColor();
shader.SetVector3("difLightColor", new Vector3(1));
shader.SetVector3("ambLightColor", new Vector3(1));
Matrix4 invertedCamera = camMat.Inverted();
Vector3 lightDirection = new Vector3(0f, 0f, -1f);
//Todo. Maybe change direction via AAMP file (configs shader data)
shader.SetVector3("specLightDirection", Vector3.TransformNormal(lightDirection, invertedCamera).Normalized());
shader.SetVector3("difLightDirection", Vector3.TransformNormal(lightDirection, invertedCamera).Normalized());
GL.Enable(EnableCap.AlphaTest);
GL.AlphaFunc(AlphaFunction.Gequal, 0.1f);
DrawModels(shader, control);
if (Runtime.renderNormalsPoints)
{
control.CurrentShader = normalsShaderProgram;
Matrix4 projection = control.mtxProj;
normalsShaderProgram.SetMatrix4x4("mtxProj", ref projection);
normalsShaderProgram.SetFloat("normalsLength", Runtime.normalsLineLength);
DrawModels(normalsShaderProgram, control);
}
GL.UseProgram(0);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
}
public EditorForm(EditorScene parent)
{
InitializeComponent();
this.parent = parent;
mapRadio.Select();
}
