internal override void SetEnums(uint clientId, uint shaderId)
{
//CSycles.shadernode_set_attribute_string(clientId, shaderId, Id, "color_space", ColorSpace.ToString());
//CSycles.shadernode_set_attribute_string(clientId, shaderId, Id, "projection", Projection.ToString());
CSycles.shadernode_set_enum(clientId, shaderId, Id, Type, "color_space", ColorSpace.ToString());
CSycles.shadernode_set_enum(clientId, shaderId, Id, Type, "projection", Projection.ToString());
}
public void SerializeToAsset()
{
var settingsAsset = ScriptableObject.CreateInstance <CurrentSettings>();
settingsAsset.SimulationMode = SimulationMode;
settingsAsset.PlayerGraphicsApi = PlayerGraphicsApi.ToString();
settingsAsset.MtRendering = MtRendering;
settingsAsset.GraphicsJobs = GraphicsJobs;
settingsAsset.ColorSpace = ColorSpace.ToString();
settingsAsset.EnabledXrTarget = XrTarget;
settingsAsset.XrsdkRevision = GetOculusXrSdkPackageVersionInfo();
settingsAsset.XrManagementRevision = GetXrManagementPackageVersionInfo();
settingsAsset.UrpPackageVersionInfo = GetUrpPackageVersionInfo();
settingsAsset.HdrpPackageVersionInfo = GetHdrpPackageVersionInfo();
settingsAsset.PerfTestsPackageRevision = GetPerfTestsPackageVersionInfo();
settingsAsset.DeviceRuntimeVersion = DeviceRuntimeVersion;
settingsAsset.Username = Username = Environment.UserName;
settingsAsset.FfrLevel = FfrLevel;
settingsAsset.TestsRevision = TestsRevision;
settingsAsset.TestsRevisionDate = TestsRevisionDate;
settingsAsset.TestsBranch = TestsBranch;
settingsAsset.AndroidTargetArchitecture = string.Format("AndroidTargetArchitecture|{0}", AndroidTargetArchitecture.ToString());
settingsAsset.RenderPipeline = RenderPipeline =
$"renderpipeline|{(GraphicsSettings.renderPipelineAsset != null ? GraphicsSettings.renderPipelineAsset.name : "BuiltInRenderer")}";
#if URP
settingsAsset.AntiAliasing = GraphicsSettings.renderPipelineAsset != null
? ((UniversalRenderPipelineAsset)GraphicsSettings.renderPipelineAsset).msaaSampleCount
: QualitySettings.antiAliasing;
#else
settingsAsset.AntiAliasing = QualitySettings.antiAliasing;
#endif
#if OCULUS_SDK
// These fields are used by the performance test framework and are an artifact from this class
// previously using the provider - specific enums before converting to a cross-platform friendly string
if (BuildTarget == BuildTarget.Android)
{
settingsAsset.StereoRenderingModeAndroid = StereoRenderingPath;
}
else
{
settingsAsset.StereoRenderingModeDesktop = StereoRenderingPath;
}
#if OCULUS_SDK_PERF
settingsAsset.PluginVersion = string.Format("OculusPluginVersion|{0}", OculusStats.PluginVersion);
#endif
#endif
#if XR_SDK
settingsAsset.StereoRenderingMode = StereoRenderingPath;
#else
// legacy xr has different enum for player settings and runtime settings for stereo rendering mode
var builtInXrStereoPath = (StereoRenderingPath)Enum.Parse(typeof(StereoRenderingPath), StereoRenderingPath);
settingsAsset.StereoRenderingMode = GetXrStereoRenderingPathMapping(builtInXrStereoPath).ToString();
#endif
CreateAndSaveCurrentSettingsAsset(settingsAsset);
}
/// <summary>
/// Converts input array pixels from one color space to another.
/// </summary>
public static CVImage ConvertColorSpace(CVImage image, ColorSpace colorSpace)
{
int numberOfChannels = (colorSpace.ToString().EndsWith("GRAY") ? 1 : 3);
CVImage dst = new CVImage(image.Width, image.Height, image.Depth, numberOfChannels);
PInvoke.cvCvtColor(new __CvArrPtr(image), new __CvArrPtr(dst), (int)colorSpace);
return(dst);
}
/// <summary>
/// Sets the color-space to decode into. The default is <see cref="ColorSpace.Rgba8888"/>.
/// </summary>
/// <param name="colorSpace">The value indicating color-space to decode into.</param>
/// <exception cref="ArgumentException"><paramref name="colorSpace"/> is invalid.</exception>
/// <exception cref="NotSupportedException"><paramref name="colorSpace"/> is not supported by the decoder.</exception>
/// <seealso cref="ImageUtil.GetSupportedColorSpaces(ImageFormat)"/>
/// <since_tizen> 4 </since_tizen>
public void SetColorSpace(ColorSpace colorSpace)
{
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(ColorSpace));
if (ImageUtil.GetSupportedColorSpaces(InputFormat).Contains(colorSpace) == false)
{
throw new NotSupportedException($"{colorSpace.ToString()} is not supported for {InputFormat}.");
}
_colorSpace = colorSpace;
}
/// <summary>
/// Sets the color-space of the output image.
/// </summary>
/// <param name="colorSpace">The target color-space.</param>
/// <exception cref="ArgumentException"><paramref name="colorSpace"/> is invalid.</exception>
/// <exception cref="NotSupportedException"><paramref name="colorSpace"/> is not supported by the encoder.</exception>
/// <seealso cref="ImageUtil.GetSupportedColorSpaces(ImageFormat)"/>
/// <since_tizen> 4 </since_tizen>
public void SetColorSpace(ColorSpace colorSpace)
{
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(colorSpace));
if (ImageUtil.GetSupportedColorSpaces(OutputFormat).Contains(colorSpace) == false)
{
throw new NotSupportedException($"{colorSpace.ToString()} is not supported for {OutputFormat}.");
}
NativeEncoder.SetColorspace(Handle, colorSpace.ToImageColorSpace()).
ThrowIfFailed("Failed to set the color space");
}
public static string Canonicalize(this ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.sRGB: return("sRGB");
case ColorSpace.AdobeRGB: return("AdobeRGB");
case ColorSpace.CMYK: return("CMYK");
case ColorSpace.HSL: return("HSL");
}
return(colorSpace.ToString());
}
public static bool SupportsTransparency(this ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.Rgb: return(true);
case ColorSpace.GrayScale: return(true);
case ColorSpace.Monochrome: return(false);
case ColorSpace.Cmyk: return(false);
default:
throw new InvalidOperationException(
"No information on transparency support for " + colorSpace.ToString());
}
}
public static FREE_IMAGE_COLOR_TYPE ToFreeImageColorType(this ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.Rgb: return(FREE_IMAGE_COLOR_TYPE.FIC_RGBALPHA);
case ColorSpace.GrayScale: return(FREE_IMAGE_COLOR_TYPE.FIC_RGBALPHA);
case ColorSpace.Monochrome: return(FREE_IMAGE_COLOR_TYPE.FIC_PALETTE);
case ColorSpace.Cmyk: return(FREE_IMAGE_COLOR_TYPE.FIC_CMYK);
default:
throw new InvalidOperationException(
"No FREE_IMAGE_COLOR_TYPE match for " + colorSpace.ToString());
}
}
public static int ToBPP(this ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.Monochrome: return(1);
case ColorSpace.Rgb: return(24);
case ColorSpace.Cmyk: return(32);
case ColorSpace.GrayScale: return(8);
default:
throw new InvalidOperationException(
"BPP not defined for " + colorSpace.ToString());
}
}
/// <summary>
/// Converts a ColorSpace value to an LCMS formatter constant, as defined
/// in <see cref="XLToolbox.Export.Lcms.Formatters"/>.
/// </summary>
/// <param name="colorSpace">ColorSpace value to convert.</param>
/// <returns>Resulting LCMS formatter constant.</returns>
/// <exception cref="InvalidOperationException">if no predefined formatter
/// constant exists for the given ColorSpace value.</exception>
private cmsUInt32Number GetLcmsPixelFormat(ColorSpace colorSpace)
{
switch (colorSpace)
{
case Models.ColorSpace.Cmyk:
return(Lcms.Formatters.TYPE_CMYK);
case Models.ColorSpace.Rgb:
return(Lcms.Formatters.TYPE_RGBA_8);
case Models.ColorSpace.GrayScale:
return(Lcms.Formatters.GRAY_8);
default:
throw new InvalidOperationException(
"No LCMS formatter defined for " + colorSpace.ToString());
}
}
public static FREE_IMAGE_COLOR_DEPTH ToFreeImageColorDepth(this ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.Monochrome: return(FREE_IMAGE_COLOR_DEPTH.FICD_01_BPP_THRESHOLD);
case ColorSpace.Rgb: return(FREE_IMAGE_COLOR_DEPTH.FICD_32_BPP);
case ColorSpace.Cmyk: return(FREE_IMAGE_COLOR_DEPTH.FICD_32_BPP);
case ColorSpace.GrayScale:
return(FREE_IMAGE_COLOR_DEPTH.FICD_FORCE_GREYSCALE | FREE_IMAGE_COLOR_DEPTH.FICD_08_BPP);
default:
throw new InvalidOperationException(
"No FREE_IMAGE_COLOR_DEPTH match for " + colorSpace.ToString());
}
}
private static List <ColorInfo> ReadSwatches(Stream stream, FileVersion version)
{
List <ColorInfo> colorInfoList = new List <ColorInfo>();
int colorCount = ReadInt16(stream);
for (int i = 0; i < colorCount; i++)
{
ColorSpace colorSpace = (ColorSpace)ReadInt16(stream);
int value1 = ReadInt16(stream);
int value2 = ReadInt16(stream);
int value3 = ReadInt16(stream);
/*int value4 = */ ReadInt16(stream); // Useful for colour spaces using 4 values (like CMYK)
string colorName = null;
if (version == FileVersion.Version2)
{
int length = ReadInt32(stream);
colorName = ReadString(stream, length);
}
switch (colorSpace)
{
case ColorSpace.RGB:
// The first 3 values in the color data are red, green and blue.
// They are full unsigned 16-bit values. Pure red = 65535, 0, 0
int r = value1 / 256; // Convert to 0-255
int g = value2 / 256; // Convert to 0-255
int b = value3 / 256; // Convert to 0-255
colorInfoList.Add(new ColorInfo(colorName, new Color(r, g, b, 255.0f)));
break;
default:
Debug.LogWarning("The color #" + i + " is in " + colorSpace.ToString() + " but Color Palette only does RGB for the time being. Skipping this color.");
break;
}
}
return(colorInfoList);
}
/// <summary>
/// Converts an XL Toolbox ColorSpace to an LCMS ColorSpaceSignature.
/// </summary>
/// <param name="colorSpace"></param>
/// <param name="colorSpace">Corresponding ColorSpaceSignature.</param>
/// <returns></returns>
public static ColorSpaceSignature FromColorSpace(this ColorSpaceSignature signature,
ColorSpace colorSpace)
{
switch (colorSpace)
{
case ColorSpace.Cmyk:
return(ColorSpaceSignature.Cmyk);
case ColorSpace.GrayScale:
return(ColorSpaceSignature.Gray);
case ColorSpace.Rgb:
return(ColorSpaceSignature.Rgb);
default:
throw new NotImplementedException(
"Color space to LCMS signature conversion for " +
colorSpace.ToString().ToUpper() +
" not implemented.");
}
}
internal static ImageColorSpace ToImageColorSpace(this ColorSpace colorSpace)
{
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(colorSpace));
switch (colorSpace)
{
case ColorSpace.YV12: return(ImageColorSpace.YV12);
case ColorSpace.Uyvy: return(ImageColorSpace.Uyvy);
case ColorSpace.Yuyv: return(ImageColorSpace.Yuyv);
case ColorSpace.Yuv422: return(ImageColorSpace.Yuv422);
case ColorSpace.I420: return(ImageColorSpace.I420);
case ColorSpace.Rgb565: return(ImageColorSpace.Rgb565);
case ColorSpace.Rgb888: return(ImageColorSpace.Rgb888);
case ColorSpace.Argb8888: return(ImageColorSpace.Argb8888);
case ColorSpace.Bgra8888: return(ImageColorSpace.Bgra8888);
case ColorSpace.Rgba8888: return(ImageColorSpace.Rgba8888);
case ColorSpace.Bgrx8888: return(ImageColorSpace.Bgrx8888);
case ColorSpace.NV12: return(ImageColorSpace.NV12);
case ColorSpace.NV16: return(ImageColorSpace.NV16);
case ColorSpace.NV21: return(ImageColorSpace.NV21);
case ColorSpace.NV61: return(ImageColorSpace.NV61);
}
throw new NotSupportedException($"The ColorSpace.{colorSpace.ToString()} is not supported.");
}
public string GetColorSpaceName()
{
return(_ColorSpace.ToString());
}
internal static VisionColorSpace ToVisionColorSpace(this ColorSpace colorSpace)
{
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(colorSpace));
switch (colorSpace)
{
case ColorSpace.Y800: return(VisionColorSpace.Y800);
case ColorSpace.I420: return(VisionColorSpace.I420);
case ColorSpace.NV12: return(VisionColorSpace.NV12);
case ColorSpace.YV12: return(VisionColorSpace.YV12);
case ColorSpace.NV21: return(VisionColorSpace.NV21);
case ColorSpace.Yuyv: return(VisionColorSpace.Yuyv);
case ColorSpace.Uyvy: return(VisionColorSpace.Uyvy);
case ColorSpace.Yuv422P: return(VisionColorSpace.Yuv422P);
case ColorSpace.Rgb565: return(VisionColorSpace.Rgb565);
case ColorSpace.Rgb888: return(VisionColorSpace.Rgb888);
case ColorSpace.Rgba8888: return(VisionColorSpace.Rgba);
}
throw new NotSupportedException("Implementation does not support the specified value." + colorSpace.ToString());
}
public void SerializeToAsset()
{
var settings = CustomMetadataManager.Instance;
var pathParts = Application.dataPath.Split('/');
settings.ProjectName = pathParts.Length >= 2 ? pathParts[pathParts.Length - 2] : string.Empty;
settings.PlayerGraphicsApi = PlayerGraphicsApi.ToString();
settings.MtRendering = MtRendering;
settings.GraphicsJobs = GraphicsJobs;
settings.EnableBurst = EnableBurst;
settings.ScriptingBackend = ScriptingImplementation.ToString();
settings.ColorSpace = ColorSpace.ToString();
settings.Username = Username = Environment.UserName;
settings.PackageUnderTestName = PackageUnderTestName;
settings.PackageUnderTestVersion = PackageUnderTestVersion;
settings.PackageUnderTestRevision = PackageUnderTestRevision;
settings.PackageUnderTestRevisionDate = PackageUnderTestRevisionDate;
settings.PackageUnderTestBranch = PackageUnderTestBranch;
settings.TestsRevision = TestsRevision;
settings.TestsRevisionDate = TestsRevisionDate;
settings.TestsBranch = TestsBranch;
settings.JobLink = JobLink;
settings.JobWorkerCount = Unity.Jobs.LowLevel.Unsafe.JobsUtility.JobWorkerCount;
settings.ApiCompatibilityLevel = ApiCompatibilityLevel.ToString();
settings.StripEngineCode = StringEngineCode;
settings.ManagedStrippingLevel = ManagedStrippingLevel.ToString();
settings.ScriptDebugging = ScriptDebugging;
settings.TestProjectName = TestProjectName;
settings.TestProjectRevision = TestProjectRevision;
settings.TestProjectRevisionDate = TestProjectRevisionDate;
settings.TestProjectBranch = TestProjectBranch;
settings.EnabledXrTarget = EnabledXrTarget;
settings.StereoRenderingMode = StereoRenderingMode;
settings.StereoRenderingModeDesktop = StereoRenderingModeDesktop;
settings.StereoRenderingModeAndroid = StereoRenderingModeAndroid;
settings.SimulationMode = SimulationMode;
settings.PluginVersion = PluginVersion;
settings.DeviceRuntimeVersion = DeviceRuntimeVersion;
settings.FfrLevel = FfrLevel;
settings.AndroidTargetArchitecture = AndroidTargetArchitecture.ToString();
GetPackageUnderTestVersionInfo(settings);
settings.RenderPipeline = RenderPipeline = $"{(GraphicsSettings.renderPipelineAsset != null ? GraphicsSettings.renderPipelineAsset.name : "BuiltInRenderer")}";
#if URP
settings.AntiAliasing = GraphicsSettings.renderPipelineAsset != null
? ((UniversalRenderPipelineAsset)GraphicsSettings.renderPipelineAsset).msaaSampleCount
: QualitySettings.antiAliasing;
#else
settings.AntiAliasing = QualitySettings.antiAliasing;
#endif
#if ENABLE_VR
#if OCULUS_SDK
// These fields are used by the performance test framework and are an artifact from this class
// previously using the provider - specific enums before converting to a cross-platform friendly string
if (BuildTarget == BuildTarget.Android)
{
settings.StereoRenderingModeAndroid = StereoRenderingMode;
}
else
{
settings.StereoRenderingModeDesktop = StereoRenderingMode;
}
#if OCULUS_SDK_PERF
settings.PluginVersion = string.Format("OculusPluginVersion|{0}", OculusStats.PluginVersion);
#endif
#endif
#if XR_SDK
settings.StereoRenderingMode = StereoRenderingMode;
#else
if (!string.IsNullOrEmpty(StereoRenderingMode))
{
// legacy xr has different enum for player settings and runtime settings for stereo rendering mode
var builtInXrStereoPath = (StereoRenderingPath)Enum.Parse(typeof(StereoRenderingPath), StereoRenderingMode);
settings.StereoRenderingMode = GetXrStereoRenderingPathMapping(builtInXrStereoPath).ToString();
}
#endif
#endif
CustomMetadataManager.SaveSettingsAssetInEditor();
}
internal override string GenerateNotSupportedErrorMessage(VideoMediaFormat format)
=> $"Converting colorspace from '{format.MimeType}' to '{ColorSpace.ToString()}' is not supported.";
public static string ColorSpaceToStringR(ColorSpace d) => d.ToString().Replace("_", " ");
/// <summary>
/// Converts input array pixels from one color space to another.
/// </summary>
public static CVImage ConvertColorSpace(CVImage image, ColorSpace colorSpace)
{
int numberOfChannels = (colorSpace.ToString().EndsWith("GRAY") ? 1 : 3);
CVImage dst = new CVImage(image.Width, image.Height, image.Depth, numberOfChannels);
PInvoke.cvCvtColor(new __CvArrPtr(image), new __CvArrPtr(dst), (int)colorSpace);
CVUtils.CheckLastError();
return dst;
}
