public void MakeCurrent()
{
if (EGL.MakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) == false)
{
throw new Exception("Failed to make EGLSurface current");
}
}
public void DestroySurface()
{
if (eglDisplay != EGL.EGL_NO_DISPLAY && eglSurface != EGL.EGL_NO_SURFACE)
{
EGL.DestroySurface(eglDisplay, eglSurface);
eglSurface = EGL.EGL_NO_SURFACE;
}
}
protected EGLBoolean createSurface(EGLConfig config)
{
eglSurface = EGL.eglCreateWindowSurface(eglDisplay, config, windType, nullptr);
if (eglSurface == EGL.EGL_NO_SURFACE)
{
return(EGL.EGL_FALSE);
}
return(EGL.EGL_TRUE);
}
private void Cleanup()
{
if (eglDisplay != EGL.EGL_NO_DISPLAY && eglContext != EGL.EGL_NO_CONTEXT)
{
EGL.DestroyContext(eglDisplay, eglContext);
eglContext = EGL.EGL_NO_CONTEXT;
}
if (eglDisplay != EGL.EGL_NO_DISPLAY)
{
EGL.Terminate(eglDisplay);
eglDisplay = EGL.EGL_NO_DISPLAY;
}
}
public void CreateSurface(SwapChainPanel panel, Size?renderSurfaceSize, float?resolutionScale)
{
if (panel == null)
{
throw new ArgumentNullException("SwapChainPanel parameter is invalid");
}
EGLSurface surface = EGL.EGL_NO_SURFACE;
int[] surfaceAttributes = new[]
{
// EGL_ANGLE_SURFACE_RENDER_TO_BACK_BUFFER is part of the same optimization as EGL_ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER (see above).
// If you have compilation issues with it then please update your Visual Studio templates.
EGLX.EGL_ANGLE_SURFACE_RENDER_TO_BACK_BUFFER, EGL.EGL_TRUE,
EGL.EGL_NONE
};
// Create a PropertySet and initialize with the EGLNativeWindowType.
PropertySet surfaceCreationProperties = new PropertySet();
surfaceCreationProperties.Add(SkiaEGL.EGLNativeWindowTypeProperty, panel);
// If a render surface size is specified, add it to the surface creation properties
if (renderSurfaceSize.HasValue)
{
PropertySetExtensions.AddSize(surfaceCreationProperties, SkiaEGL.EGLRenderSurfaceSizeProperty, renderSurfaceSize.Value);
}
// If a resolution scale is specified, add it to the surface creation properties
if (resolutionScale.HasValue)
{
PropertySetExtensions.AddSingle(surfaceCreationProperties, SkiaEGL.EGLRenderResolutionScaleProperty, resolutionScale.Value);
}
surface = EGL.CreateWindowSurface(eglDisplay, eglConfig, surfaceCreationProperties, surfaceAttributes);
if (surface == EGL.EGL_NO_SURFACE)
{
throw new Exception("Failed to create EGL surface");
}
eglSurface = surface;
}
protected EGLBoolean createEGLEnv()
{
EGLint numConfigs = 0;
EGLint[] contextAttribs = { EGL.EGL_CONTEXT_CLIENT_VERSION, 2, EGL.EGL_NONE, EGL.EGL_NONE };
eglDisplay = EGL.eglGetDisplay(EGL.EGL_DEFAULT_DISPLAY);
if (eglDisplay == EGL.EGL_NO_DISPLAY)
{
return(EGL.EGL_FALSE);
}
if (EGL.eglInitialize(eglDisplay, ref majorVersion, ref minorVersion) == EGL.EGL_FALSE)
{
return(EGL.EGL_FALSE);
}
if (EGL.eglGetConfigs(eglDisplay, nullptr, 0, ref numConfigs) == EGL.EGL_FALSE)
{
return(EGL.EGL_FALSE);
}
if (chooseConfig(ref config, ref numConfigs) == 0)
{
return(EGL.EGL_FALSE);
}
if (createSurface(config) == EGL.EGL_FALSE)
{
return(EGL.EGL_FALSE);
}
eglContext = EGL.eglCreateContext(eglDisplay, config, EGL.EGL_NO_CONTEXT, contextAttribs);
if (eglContext == EGL.EGL_NO_CONTEXT)
{
return(EGL.EGL_FALSE);
}
;
return(UseContext());
}
protected EGLBoolean chooseConfig(ref EGLConfig config, ref EGLint numConfigs)
{
EGLint[] attribList =
{
EGL.EGL_RED_SIZE, 8,
EGL.EGL_GREEN_SIZE, 8,
EGL.EGL_BLUE_SIZE, 8,
EGL.EGL_ALPHA_SIZE, 8,
EGL.EGL_DEPTH_SIZE, 8,
EGL.EGL_STENCIL_SIZE, 8,
EGL.EGL_SAMPLE_BUFFERS, 1,
EGL.EGL_SAMPLES, 4,
EGL.EGL_NONE
};
if (EGL.eglChooseConfig(eglDisplay, attribList, ref config, 1, ref numConfigs) == EGL.EGL_FALSE)
{
int err = EGL.eglGetError();
return(EGL.EGL_FALSE);
}
return(EGL.EGL_TRUE);
}
public override void Stop()
{
EGL.Terminate(GlDisplay);
GLES2Config.GlCheckError(this);
}
void DrawGUI_Android(P.Params currentParams)
{
int opt = currentParams.platformOption;
//bool fold;
//using( new GUILayout.VerticalScope( s_styles.HelpBox ) ) {
// using( new GUILayout.HorizontalScope() ) {
// EditorGUI.BeginChangeCheck();
// fold = EditorGUILayout.Foldout( BuildManagerSettingsEditor.i.fold.Has( BuildManagerSettingsEditor.FoldPlatform ), "Player Settings", s_styles.Foldout );
// BuildManagerSettingsEditor.i.fold.Toggle( BuildManagerSettingsEditor.FoldPlatform, fold );
// if( EditorGUI.EndChangeCheck() ) s_changed = true;
// GUILayout.FlexibleSpace();
// var r = GUILayoutUtility.GetRect( 20, 18 );
// GUI.Label( r, s_styles.Settings, s_styles.Icon );
// if( EditorHelper.HasMouseClick( GUILayoutUtility.GetLastRect() ) ) {
// Selection.activeObject = AssetDatabase.LoadAssetAtPath<UnityObject>( AssetDatabase.GUIDToAssetPath( "00000000000000004000000000000000" ) );
// EditorUtils.InspectorWindow().Focus();
// Event.current.Use();
// }
// }
// EditorGUI.BeginChangeCheck();
// if( fold ) {
// EditorGUI.indentLevel++;
// currentParams.scriptingBackend = (ScriptingImplementation) EditorGUILayout.Popup( L.Tr( "ScriptingBackend" ), (int) currentParams.scriptingBackend, s_scriptingBackend );
// using( new EditorGUI.DisabledGroupScope( currentParams.scriptingBackend == ScriptingImplementation.Mono2x ) ) {
// currentParams.il2CppCompilerConfiguration = (Il2CppCompilerConfiguration) EditorGUILayout.EnumPopup( L.Tr( "C++ Compiler Configuration" ), currentParams.il2CppCompilerConfiguration );
// }
// EditorGUILayout.LabelField( $"{L.Tr( "Scripting Define Symbols" )} ({L.Tr( "Additional" )})" );
// currentParams.scriptingDefineSymbols = EditorGUILayout.TextField( currentParams.scriptingDefineSymbols );
// EditorGUILayout.LabelField( $"{L.Tr( "Scripting Define Symbols" )} ({L.Tr( "Current" )})" );
// EditorGUI.BeginDisabledGroup( true );
// EditorGUILayout.TextField( B.scriptingDefineSymbols );
// EditorGUI.EndDisabledGroup();
// EditorGUI.indentLevel--;
// GUILayout.Space( 4 );
// }
// if( EditorGUI.EndChangeCheck() ) {
// currentParams.platformOption = opt;
// s_changed = true;
// }
//}
GUILayout.Space(4);
DrawGUI_3rdpartySettings();
#if false //保留
currentParams.DEBUG_LOG = EGL.Toggle("DEBUG_LOG", currentParams.DEBUG_LOG);
BuildManagerPreference.i.adb_exe = EGL.TextField("adb.exe", BuildManagerPreference.i.adb_exe);
BuildManagerPreference.i.bundletool_jar = EGL.TextField("bundletool", BuildManagerPreference.i.bundletool_jar);
using (new GL.HorizontalScope()) {
GL.FlexibleSpace();
GL.Button("Install on device");
GL.Button("Launch on device");
}
#endif
GUILayout.Space(4);
EditorGUI.BeginChangeCheck();
using (new GUILayout.HorizontalScope()) {
GUILayout.Label($"Version", EditorStyles.label);
GUILayout.Label($"{PlayerSettings.bundleVersion}", EditorStyles.label);
var a = GUILayoutUtility.GetLastRect();
a.x += a.width;
a.width = 8;
a.height = 8;
//a.x -= 6;
var rcU = a;
rcU.y -= 0;
var rcD = a;
rcD.y += 0 + a.height;
if (GUI.Button(rcU, Styles.iconAllowUp, Styles.icon))
{
var f = float.Parse(PlayerSettings.bundleVersion);
int i = (int)((f * 100.0f + 0.5f));
i += 100;
f = ((float)i) / 100.0f;
PlayerSettings.bundleVersion = f.ToString("F2");
}
if (GUI.Button(rcD, Styles.iconAllowDown, Styles.icon))
{
var f = float.Parse(PlayerSettings.bundleVersion);
int i = (int)((f * 100.0f + 0.5f));
i -= 100;
f = ((float)i) / 100.0f;
PlayerSettings.bundleVersion = f.ToString("F2");
}
rcU.x += 8;
rcD.x += 8;
if (GUI.Button(rcU, Styles.iconAllowUp, Styles.icon))
{
var f = float.Parse(PlayerSettings.bundleVersion);
int i = (int)((f * 100.0f + 0.5f));
i++;
f = ((float)i) / 100.0f;
PlayerSettings.bundleVersion = f.ToString("F2");
}
if (GUI.Button(rcD, Styles.iconAllowDown, Styles.icon))
{
var f = float.Parse(PlayerSettings.bundleVersion);
int i = (int)((f * 100.0f + 0.5f));
i--;
f = ((float)i) / 100.0f;
PlayerSettings.bundleVersion = f.ToString("F2");
}
GUILayout.Space(20);
GUILayout.Label($"Bundle Version Code", EditorStyles.label);
GUILayout.Label($"{PlayerSettings.Android.bundleVersionCode}", EditorStyles.label);
a = GUILayoutUtility.GetLastRect();
a.x += a.width;
a.width = 8;
a.height = 8;
rcU = a;
rcU.y -= 0;
rcD = a;
rcD.y += 0 + a.height;
if (GUI.Button(rcU, Styles.iconAllowUp, Styles.icon))
{
PlayerSettings.Android.bundleVersionCode++;
}
if (GUI.Button(rcD, Styles.iconAllowDown, Styles.icon))
{
PlayerSettings.Android.bundleVersionCode--;
}
GUILayout.FlexibleSpace();
}
if (EditorGUI.EndChangeCheck())
{
s_changed = true;
}
bool once = false;
void errorLabel(string s, string icon = "")
{
var c = EditorStyles.label.normal.textColor;
EditorStyles.label.normal.textColor = Color.red;
EditorStyles.label.fontStyle = FontStyle.Bold;
GUILayout.Label(EditorHelper.TempContent(s, Icon.Get(icon)), EditorStyles.label);
EditorStyles.label.fontStyle = FontStyle.Normal;
EditorStyles.label.normal.textColor = c;
}
void errorTitle()
{
if (once)
{
return;
}
errorLabel(L.Tr("PlayerSettings.Android settings are incomplete"), "console.erroricon.sml");
once = true;
}
if (PlayerSettings.Android.bundleVersionCode == 0)
{
errorTitle();
errorLabel(L.Tr($"If BundleVersionCode is 0, a build error occurs"));
}
if (B.applicationIdentifier.IsEmpty())
{
errorTitle();
errorLabel(L.Tr($"PackageName of Identification is empty"));
}
else if (B.applicationIdentifier == "com.Company.ProductName")
{
errorTitle();
errorLabel(L.Tr($"An error occurs if PackageName is \"com.Company.ProductName\""));
}
else if (!B.applicationIdentifier.Contains("."))
{
errorTitle();
errorLabel(L.Tr($"PackageName must be separated by at least one .(Dot)"));
}
else if (B.applicationIdentifier[0] == '.')
{
errorTitle();
errorLabel(L.Tr($"An error occurs if PackageName starts with a .(Dot)"));
}
else if (B.applicationIdentifier[B.applicationIdentifier.Length - 1] == '.')
{
errorTitle();
errorLabel(L.Tr($"An error occurs if the end of PackageName is .(Dot)"));
}
}
private void Initialize()
{
int[] configAttributes = new[]
{
EGL.EGL_RED_SIZE, 8,
EGL.EGL_GREEN_SIZE, 8,
EGL.EGL_BLUE_SIZE, 8,
EGL.EGL_ALPHA_SIZE, 8,
EGL.EGL_DEPTH_SIZE, 8,
EGL.EGL_STENCIL_SIZE, 8,
EGL.EGL_NONE
};
int[] contextAttributes = new[]
{
EGL.EGL_CONTEXT_CLIENT_VERSION, 2,
EGL.EGL_NONE
};
int[] defaultDisplayAttributes = new[]
{
// These are the default display attributes, used to request ANGLE's D3D11 renderer.
// eglInitialize will only succeed with these attributes if the hardware supports D3D11 Feature Level 10_0+.
EGLX.EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGLX.EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
// EGL_ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER is an optimization that can have large performance benefits on mobile devices.
// Its syntax is subject to change, though. Please update your Visual Studio templates if you experience compilation issues with it.
EGLX.EGL_ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.EGL_TRUE,
// EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE is an option that enables ANGLE to automatically call
// the IDXGIDevice3::Trim method on behalf of the application when it gets suspended.
// Calling IDXGIDevice3::Trim when an application is suspended is a Windows Store application certification requirement.
EGLX.EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.EGL_TRUE,
EGL.EGL_NONE,
};
int[] fl9_3DisplayAttributes = new[]
{
// These can be used to request ANGLE's D3D11 renderer, with D3D11 Feature Level 9_3.
// These attributes are used if the call to eglInitialize fails with the default display attributes.
EGLX.EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGLX.EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
EGLX.EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, 9,
EGLX.EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE, 3,
EGLX.EGL_ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.EGL_TRUE,
EGLX.EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.EGL_TRUE,
EGL.EGL_NONE,
};
int[] warpDisplayAttributes = new[]
{
// These attributes can be used to request D3D11 WARP.
// They are used if eglInitialize fails with both the default display attributes and the 9_3 display attributes.
EGLX.EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGLX.EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
EGLX.EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGLX.EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE,
EGLX.EGL_ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.EGL_TRUE,
EGLX.EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.EGL_TRUE,
EGL.EGL_NONE,
};
EGLConfig config = IntPtr.Zero;
//
// To initialize the display, we make three sets of calls to eglGetPlatformDisplayEXT and eglInitialize, with varying
// parameters passed to eglGetPlatformDisplayEXT:
// 1) The first calls uses "defaultDisplayAttributes" as a parameter. This corresponds to D3D11 Feature Level 10_0+.
// 2) If eglInitialize fails for step 1 (e.g. because 10_0+ isn't supported by the default GPU), then we try again
// using "fl9_3DisplayAttributes". This corresponds to D3D11 Feature Level 9_3.
// 3) If eglInitialize fails for step 2 (e.g. because 9_3+ isn't supported by the default GPU), then we try again
// using "warpDisplayAttributes". This corresponds to D3D11 Feature Level 11_0 on WARP, a D3D11 software rasterizer.
//
// This tries to initialize EGL to D3D11 Feature Level 10_0+. See above comment for details.
eglDisplay = EGLX.GetPlatformDisplayEXT(EGLX.EGL_PLATFORM_ANGLE_ANGLE, EGL.EGL_DEFAULT_DISPLAY, defaultDisplayAttributes);
if (eglDisplay == EGL.EGL_NO_DISPLAY)
{
throw new Exception("Failed to get EGL display");
}
if (EGL.Initialize(eglDisplay, out int major, out int minor) == false)
{
// This tries to initialize EGL to D3D11 Feature Level 9_3, if 10_0+ is unavailable (e.g. on some mobile devices).
eglDisplay = EGLX.GetPlatformDisplayEXT(EGLX.EGL_PLATFORM_ANGLE_ANGLE, EGL.EGL_DEFAULT_DISPLAY, fl9_3DisplayAttributes);
if (eglDisplay == EGL.EGL_NO_DISPLAY)
{
throw new Exception("Failed to get EGL display");
}
if (EGL.Initialize(eglDisplay, out major, out minor) == false)
{
// This initializes EGL to D3D11 Feature Level 11_0 on WARP, if 9_3+ is unavailable on the default GPU.
eglDisplay = EGLX.GetPlatformDisplayEXT(EGLX.EGL_PLATFORM_ANGLE_ANGLE, EGL.EGL_DEFAULT_DISPLAY, warpDisplayAttributes);
if (eglDisplay == EGL.EGL_NO_DISPLAY)
{
throw new Exception("Failed to get EGL display");
}
if (EGL.Initialize(eglDisplay, out major, out minor) == false)
{
// If all of the calls to eglInitialize returned EGL_FALSE then an error has occurred.
throw new Exception("Failed to initialize EGL");
}
}
}
EGLDisplay_ configs;
if ((EGL.ChooseConfig(eglDisplay, configAttributes, out configs, 1, out int numConfigs) == false) || (numConfigs == 0))
{
throw new Exception("Failed to choose first EGLConfig");
}
eglConfig = configs;
eglContext = EGL.CreateContext(eglDisplay, eglConfig, EGL.EGL_NO_CONTEXT, contextAttributes);
if (eglContext == EGL.EGL_NO_CONTEXT)
{
throw new Exception("Failed to create EGL context");
}
}
public bool SwapBuffers()
{
return(EGL.SwapBuffers(eglDisplay, eglSurface) == true);
}
public void GetSurfaceDimensions(out int width, out int height)
{
EGL.QuerySurface(eglDisplay, eglSurface, EGL.EGL_WIDTH, out width);
EGL.QuerySurface(eglDisplay, eglSurface, EGL.EGL_HEIGHT, out height);
}
public EGLBoolean UseContext()
{
return(EGL.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext));
}
public void SwapBuffer()
{
EGL.eglSwapBuffers(eglDisplay, eglSurface);
}
extern static uint eglBindAPI(EGL api); // returns EGLboolean
