/// <summary>
/// Gets the image white balance information.
/// </summary>
/// <returns></returns>
private WhiteBalance GetImageWhiteBalance()
{
WhiteBalance wbInfo = new WhiteBalance();
try
{
PropertyItem piWhiteBalanceInfo = GetImageProperty(Constants.WhiteBalance);
if (piWhiteBalanceInfo != null && piWhiteBalanceInfo.Type == 3)
{
double whiteBalanceModeInfoValue = 0.00;
for (int count = 0; count < piWhiteBalanceInfo.Value.Length; count++)
{
whiteBalanceModeInfoValue += piWhiteBalanceInfo.Value[count] * Math.Pow(256, count);
}
int whiteBalanceModeInfoData = Convert.ToInt32(whiteBalanceModeInfoValue);
wbInfo = (WhiteBalance)whiteBalanceModeInfoData;
}
else
{
wbInfo = WhiteBalance.Unknown;
}
}
catch (Exception)
{
wbInfo = WhiteBalance.Unknown;
}
return(wbInfo);
}
/// <summary>
/// Gets all the image property values.
/// </summary>
private void GetAllImagePropertyValues()
{
try
{
this.cameraMake = GetCameraMake();
this.cameraModel = GetCameraSpecificModel();
this.aperture = GetApertureData();
this.shutterSpeed = GetExposureTime();
this.iso = GetISOInformation();
this.focalLength = GetFocalLengthInformation();
this.pixelXDimension = GetPixelDimension(Dimension.X);
this.pixelYDimension = GetPixelDimension(Dimension.Y);
this.imageFileSource = GetImageFileSource();
this.flash = GetFlashInformation();
this.createdDateTimeStamp = GetImageDateTimeStamps(ImageTimeStamps.Created);
this.modifiedDateTimeStamp = GetImageDateTimeStamps(ImageTimeStamps.Modified);
this.exposureCompensation = GetExposureCompensation();
this.imageSceneMode = GetImageSceneMode();
this.meteringMode = GetMeteringModeInfo();
this.imageExposureMode = GetImageExposureMode();
this.imageWhiteBalance = GetImageWhiteBalance();
this.imageSubjectDistanceRange = GetImageSubjectDistanceInformation();
this.focalLength35mmEquivalent = GetFocalLength35mmEquivalent();
}
catch (Exception)
{
}
}
private void SetCameraSettings(AEMode aeMode, WhiteBalance balance, ApertureValue apertureValue,
CameraISOSensitivity cameraIsoSensitivity, ShutterSpeed shutterSpeed)
{
//_imageProcessor.SetSetting((uint)PropertyId.AEMode, (uint)aeMode); TODO Не поддерживается Eos 1100
_imageProcessor.SetSetting((uint)PropertyId.WhiteBalance, (uint)balance);
_imageProcessor.SetSetting((uint)PropertyId.Av, (uint)apertureValue);
//_imageProcessor.SetSetting((uint)PropertyId.ExposureCompensation, (uint)));
_imageProcessor.SetSetting((uint)PropertyId.ISOSpeed, (uint)cameraIsoSensitivity);
_imageProcessor.SetSetting((uint)PropertyId.Tv, (uint)shutterSpeed);
}
public virtual async Task<CompositionProcessingResult> TakePictureAsync(byte[] liveViewImageStream, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
Size liveViewImageStreamSize;
using (var stream = new MemoryStream(liveViewImageStream))
{
var img = Image.FromStream(stream);
liveViewImageStreamSize = img.Size;
}
return new CompositionProcessingResult(_pattern, await TakePictureInternal(liveViewImageStreamSize, selectedAeMode, selectedAvValue, selectedIsoSensitivity, selectedShutterSpeed, selectedWhiteBalance, token));
}
void OnDestroy()
{
GameObject.Destroy(this.lightObject);
this.lightObject = null;
this.skyDirectionalLight = null;
this.hdLight = null;
this.timer = null;
this.dayFlare = null;
this.nightFlare = null;
this.volume = null;
this.pbsky = null;
this.clouds = null;
this.whiteBalance = null;
}
private async Task<byte[]> Run(Size liveViewImageStreamSize, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
var settings = GetCameraPhotoSettings();
List<byte[]> pictures = new List<byte[]>();
for (int i = 0; i < _pattern.Images.Count; i++)
{
token.ThrowIfCancellationRequested();
RaiseImageNumberChanged(i + 1);
RaiseTimerElapsed(4);
await Task.Delay(TimeSpan.FromSeconds(2), token);
for (int j = 3; j >= 0; j--)
{
RaiseTimerElapsed(j);
await Task.Delay(TimeSpan.FromSeconds(1), token);
}
SetCameraSettings(Enum.Parse(typeof(AEMode), settings.SelectedAeMode),
Enum.Parse(typeof(WhiteBalance), settings.SelectedWhiteBalance),
Enum.Parse(typeof(ApertureValue), settings.SelectedAvValue),
Enum.Parse(typeof(CameraISOSensitivity), settings.SelectedIsoSensitivity),
Enum.Parse(typeof(ShutterSpeed), settings.SelectedShutterSpeed));
//await Task.Delay(TimeSpan.FromSeconds(1));
//RaiseImageNumberChanged(i + 1);
// await Task.Delay(TimeSpan.FromSeconds(1), token);
token.ThrowIfCancellationRequested();
byte[] picture = await _imageProcessor.DoTakePicture();
pictures.Add(picture);
token.ThrowIfCancellationRequested();
// await Task.Delay(TimeSpan.FromSeconds(3), token); //todo
SetCameraSettings(selectedAeMode, selectedWhiteBalance,
selectedAvValue, selectedIsoSensitivity,
selectedShutterSpeed);
StopLiveView();
StartLiveView();
}
byte[] result = _imageUtils.ProcessImages(pictures, liveViewImageStreamSize, _pattern);
return result;
}
private void Awake()
{
player = GameObject.FindWithTag("Player")?.transform;
characterManager = player.GetComponent <CharacterManager>();
torch = player.GetComponentInChildren <Torch>();
layerManager = GameObject.FindWithTag("Game Controller")?.GetComponent <LayerManager>();
temperature = postProcessing.components[1] as WhiteBalance;
deathAnimator = GameObject.FindWithTag("UI")?.GetComponent <Animator>();
if (!player || !layerManager || !postProcessing || !temperature)
{
throw new Exception("LOL XD");
}
tickCounter = 0;
tickToDieInDark = lifeTimeInDark;
savedObjects = new List <DestructableEntity>();
}
async void InitMediaCapture()
{
_imageProperties = ImageEncodingProperties.CreateBmp();
_imageProperties.Width = WIDTH;
_imageProperties.Height = HEIGHT;
Camera = new MediaCapture();
var settings = new MediaCaptureInitializationSettings
{
MediaCategory = MediaCategory.Media
};
await Camera.InitializeAsync(settings);
Camera.VideoDeviceController.DesiredOptimization = MediaCaptureOptimization.Quality;
Camera.VideoDeviceController.PrimaryUse = CaptureUse.Photo;
WhiteBalance = Camera.VideoDeviceController.WhiteBalance;
WhiteBalSlider.Minimum = WhiteBalance.Capabilities.Min;
WhiteBalSlider.Maximum = WhiteBalance.Capabilities.Max;
Double value;
WhiteBalance.TryGetValue(out value);
WhiteBalSlider.Value = value;
PreviewElement.Source = Camera;
await Camera.StartPreviewAsync();
await TakePicture();
Task.Run(async() =>
{
while (true)
{
await TakePicture();
Task.Delay(100).Wait();
}
});
InitTimer();
}
public string AsWhiteBalance()
{
WhiteBalance whiteBalance = (WhiteBalance)Value;
switch (whiteBalance)
{
case WhiteBalance.Auto: return("Auto");
case WhiteBalance.Daylight: return("Daylight");
case WhiteBalance.Incandescent: return("Incandescent");
case WhiteBalance.Flash: return("Flash");
case WhiteBalance.Fluor_WarmWhite: return("Fluor: Warm White");
case WhiteBalance.Fluor_CoolWhite: return("Fluor: Cool White");
case WhiteBalance.Fluor_DayWhite: return("Fluor: Day White");
case WhiteBalance.Fluor_Daylight: return("Fluor: Daylight");
case WhiteBalance.Cloudy: return("Cloudy");
case WhiteBalance.Shade: return("Shade");
case WhiteBalance.CTempFilter: return("C.Temp/Filter");
case WhiteBalance.Custom1: return("Custom 1");
case WhiteBalance.Custom2: return("Custom 2");
case WhiteBalance.Custom3: return("Custom 3");
case WhiteBalance.UnderwaterAuto: return("Underwater Auto");
default: return("???(" + Value + ")");
}
}
/// <summary>
/// config the snapshot
/// </summary>
/// <param name="wb">WhiteBalance</param>
/// <param name="ev">explosure value</param>
/// <param name="contrast">Contrast</param>
/// <param name="ce">ColorEffect</param>
/// <param name="sharp">Sharpness</param>
/// <returns>True if succeed</returns>
public bool ConfigSnapshot(WhiteBalance wb, EV ev, Contrast contrast, ColorEffect ce, Sharpness sharp)
{
byte[] writeBuffer = new byte[5];
writeBuffer[0] = (byte)wb;
writeBuffer[1] = (byte)ev;
writeBuffer[2] = (byte)contrast;
writeBuffer[3] = (byte)ce;
writeBuffer[4] = (byte)sharp;
CreatCommand(5, CMD_SNAPSHOT_CONFIG);
CreatCommand(writeBuffer);
SendCommand(id_cmd);
SendCommand(para_cmd);
if (!ReceiveACK(CMD_SNAPSHOT_CONFIG, 100))
{
return(false);
}
return(true);
}
public void SetWhiteBalance(WhiteBalance whiteBalance)
{
DoSubSettingI16(SettingIds.WhiteBalance, (short)whiteBalance);
}
public virtual async Task <CompositionProcessingResult> TakePictureAsync(byte[] liveViewImageStream, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
Size liveViewImageStreamSize;
using (var stream = new MemoryStream(liveViewImageStream))
{
var img = Image.FromStream(stream);
liveViewImageStreamSize = img.Size;
}
return(new CompositionProcessingResult(_pattern, await TakePictureInternal(liveViewImageStreamSize, selectedAeMode, selectedAvValue, selectedIsoSensitivity, selectedShutterSpeed, selectedWhiteBalance, token)));
}
Tag CreateSpecificTag(TagInfo info, string numberValue)
{
try
{
if (info.IsGps)
{
switch (info.Name.ToLower())
{
case "gpslatituderef":
return(new Tag <GpsLatitudeRef> {
TypedValue = GpsLatitudeRef.FromKey(numberValue)
});
case "gpslongituderef":
return(new Tag <GpsLongitudeRef> {
TypedValue = GpsLongitudeRef.FromKey(numberValue)
});
case "gpsaltituderef":
return(new Tag <GpsAltitudeRef> {
TypedValue = GpsAltitudeRef.FromKey(byte.Parse(numberValue))
});
case "gpsstatus":
return(new Tag <GpsStatus> {
TypedValue = GpsStatus.FromKey(numberValue)
});
case "gpsmeasuremode":
return(new Tag <GpsMeasureMode> {
TypedValue = GpsMeasureMode.FromKey(numberValue)
});
case "gpsspeedref":
return(new Tag <GpsSpeedRef> {
TypedValue = GpsSpeedRef.FromKey(numberValue)
});
case "gpstrackref":
return(new Tag <GpsTrackRef> {
TypedValue = GpsTrackRef.FromKey(numberValue)
});
case "gpsimgdirectionref":
return(new Tag <GpsImgDirectionRef> {
TypedValue = GpsImgDirectionRef.FromKey(numberValue)
});
case "gpsdestlatituderef":
return(new Tag <GpsDestLatitudeRef> {
TypedValue = GpsDestLatitudeRef.FromKey(numberValue)
});
case "gpsdestlongituderef":
return(new Tag <GpsDestLongitudeRef> {
TypedValue = GpsDestLongitudeRef.FromKey(numberValue)
});
case "gpsdestbearingref":
return(new Tag <GpsDestBearingRef> {
TypedValue = GpsDestBearingRef.FromKey(numberValue)
});
case "gpsdestdistanceref":
return(new Tag <GpsDestDistanceRef> {
TypedValue = GpsDestDistanceRef.FromKey(numberValue)
});
case "gpsdifferential":
return(new Tag <GpsDifferential> {
TypedValue = GpsDifferential.FromKey(ushort.Parse(numberValue))
});
}
}
if (info.IsNikon)
{
switch (info.Name.ToLower())
{
case "colorspace":
return(new Tag <NikonColorSpace> {
TypedValue = NikonColorSpace.FromKey(ushort.Parse(numberValue))
});
case "vibrationreduction":
return(new Tag <NikonVibrationReduction> {
TypedValue = NikonVibrationReduction.FromKey(byte.Parse(numberValue))
});
case "vrmode":
return(new Tag <NikonVRMode> {
TypedValue = NikonVRMode.FromKey(byte.Parse(numberValue))
});
case "imageauthentication":
return(new Tag <NikonImageAuthentication> {
TypedValue = NikonImageAuthentication.FromKey(byte.Parse(numberValue))
});
case "actived-lighting":
return(new Tag <NikonActiveDLighting> {
TypedValue = NikonActiveDLighting.FromKey(ushort.Parse(numberValue))
});
case "picturecontroladjust":
return(new Tag <NikonPictureControlAdjust> {
TypedValue = NikonPictureControlAdjust.FromKey(byte.Parse(numberValue))
});
case "filtereffect":
return(new Tag <NikonFilterEffect> {
TypedValue = NikonFilterEffect.FromKey(byte.Parse(numberValue))
});
case "toningeffect":
return(new Tag <NikonToningEffect> {
TypedValue = NikonToningEffect.FromKey(byte.Parse(numberValue))
});
case "daylightsavings":
return(new Tag <NikonDaylightSavings> {
TypedValue = NikonDaylightSavings.FromKey(byte.Parse(numberValue))
});
case "datedisplayformat":
return(new Tag <NikonDateDisplayFormat> {
TypedValue = NikonDateDisplayFormat.FromKey(byte.Parse(numberValue))
});
case "isoexpansion":
return(new Tag <NikonIsoExpansion> {
TypedValue = NikonIsoExpansion.FromKey(ushort.Parse(numberValue))
});
case "isoexpansion2":
return(new Tag <NikonIsoExpansion2> {
TypedValue = NikonIsoExpansion2.FromKey(ushort.Parse(numberValue))
});
case "vignettecontrol":
return(new Tag <NikonVignetteControl> {
TypedValue = NikonVignetteControl.FromKey(ushort.Parse(numberValue))
});
case "autodistortioncontrol":
return(new Tag <NikonAutoDistortionControl> {
TypedValue = NikonAutoDistortionControl.FromKey(byte.Parse(numberValue))
});
case "hdr":
return(new Tag <NikonHdr> {
TypedValue = NikonHdr.FromKey(byte.Parse(numberValue))
});
case "hdrlevel":
return(new Tag <NikonHdrLevel> {
TypedValue = NikonHdrLevel.FromKey(byte.Parse(numberValue))
});
case "hdrsmoothing":
return(new Tag <NikonHdrSmoothing> {
TypedValue = NikonHdrSmoothing.FromKey(byte.Parse(numberValue))
});
case "hdrlevel2":
return(new Tag <NikonHdrLevel2> {
TypedValue = NikonHdrLevel2.FromKey(byte.Parse(numberValue))
});
case "textencoding":
return(new Tag <NikonTextEncoding> {
TypedValue = NikonTextEncoding.FromKey(byte.Parse(numberValue))
});
case "flashmode":
return(new Tag <NikonFlashMode> {
TypedValue = NikonFlashMode.FromKey(byte.Parse(numberValue))
});
case "afareamode":
return(new Tag <NikonAfAreaMode> {
TypedValue = NikonAfAreaMode.FromKey(byte.Parse(numberValue))
});
case "afpoint":
return(new Tag <NikonAfPoint> {
TypedValue = NikonAfPoint.FromKey(byte.Parse(numberValue))
});
case "afpointsinfocus":
return(new Tag <NikonAfPointsInFocus> {
TypedValue = NikonAfPointsInFocus.FromKey(ushort.Parse(numberValue))
});
case "nefcompression":
return(new Tag <NikonNefCompression> {
TypedValue = NikonNefCompression.FromKey(ushort.Parse(numberValue))
});
case "retouchhistory":
return(new Tag <NikonRetouchHistory> {
TypedValue = NikonRetouchHistory.FromKey(ushort.Parse(numberValue))
});
case "flashsource":
return(new Tag <NikonFlashSource> {
TypedValue = NikonFlashSource.FromKey(byte.Parse(numberValue))
});
case "flashcolorfilter":
return(new Tag <NikonFlashColorFilter> {
TypedValue = NikonFlashColorFilter.FromKey(byte.Parse(numberValue))
});
case "highisonoisereduction":
return(new Tag <NikonHighIsoNoiseReduction> {
TypedValue = NikonHighIsoNoiseReduction.FromKey(ushort.Parse(numberValue))
});
}
}
if (info.IsExif)
{
switch (info.Name.ToLower())
{
case "interopindex":
return(new Tag <InteropIndex> {
TypedValue = InteropIndex.FromKey(numberValue)
});
case "subfiletype":
return(new Tag <SubfileType> {
TypedValue = SubfileType.FromKey(uint.Parse(numberValue))
});
case "oldsubfiletype":
return(new Tag <OldSubfileType> {
TypedValue = OldSubfileType.FromKey(ushort.Parse(numberValue))
});
case "compression":
return(new Tag <Compression> {
TypedValue = Compression.FromKey(ushort.Parse(numberValue))
});
case "photometricinterpretation":
return(new Tag <PhotometricInterpretation> {
TypedValue = PhotometricInterpretation.FromKey(ushort.Parse(numberValue))
});
case "thresholding":
return(new Tag <Thresholding> {
TypedValue = Thresholding.FromKey(ushort.Parse(numberValue))
});
case "fillorder":
return(new Tag <FillOrder> {
TypedValue = FillOrder.FromKey(ushort.Parse(numberValue))
});
case "orientation":
return(new Tag <Orientation> {
TypedValue = Orientation.FromKey(ushort.Parse(numberValue))
});
case "planarconfiguration":
return(new Tag <PlanarConfiguration> {
TypedValue = PlanarConfiguration.FromKey(ushort.Parse(numberValue))
});
case "grayresponseunit":
return(new Tag <GrayResponseUnit> {
TypedValue = GrayResponseUnit.FromKey(ushort.Parse(numberValue))
});
case "resolutionunit":
return(new Tag <ResolutionUnit> {
TypedValue = ResolutionUnit.FromKey(ushort.Parse(numberValue))
});
case "predictor":
return(new Tag <Predictor> {
TypedValue = Predictor.FromKey(ushort.Parse(numberValue))
});
case "cleanfaxdata":
return(new Tag <CleanFaxData> {
TypedValue = CleanFaxData.FromKey(ushort.Parse(numberValue))
});
case "inkset":
return(new Tag <InkSet> {
TypedValue = InkSet.FromKey(ushort.Parse(numberValue))
});
case "extrasamples":
return(new Tag <ExtraSamples> {
TypedValue = ExtraSamples.FromKey(ushort.Parse(numberValue))
});
case "sampleformat":
return(new Tag <SampleFormat> {
TypedValue = SampleFormat.FromKey(ushort.Parse(numberValue))
});
case "indexed":
return(new Tag <Indexed> {
TypedValue = Indexed.FromKey(ushort.Parse(numberValue))
});
case "opiproxy":
return(new Tag <OpiProxy> {
TypedValue = OpiProxy.FromKey(ushort.Parse(numberValue))
});
case "profiletype":
return(new Tag <ProfileType> {
TypedValue = ProfileType.FromKey(ushort.Parse(numberValue))
});
case "faxprofile":
return(new Tag <FaxProfile> {
TypedValue = FaxProfile.FromKey(ushort.Parse(numberValue))
});
case "jpegproc":
return(new Tag <JpegProc> {
TypedValue = JpegProc.FromKey(ushort.Parse(numberValue))
});
case "ycbcrsubsampling":
return(new Tag <YCbCrSubSampling> {
TypedValue = YCbCrSubSampling.FromKey(numberValue)
});
case "ycbcrpositioning":
return(new Tag <YCbCrPositioning> {
TypedValue = YCbCrPositioning.FromKey(ushort.Parse(numberValue))
});
case "sonyrawfiletype":
return(new Tag <SonyRawFileType> {
TypedValue = SonyRawFileType.FromKey(ushort.Parse(numberValue))
});
case "rasterpadding":
return(new Tag <RasterPadding> {
TypedValue = RasterPadding.FromKey(ushort.Parse(numberValue))
});
case "imagecolorindicator":
return(new Tag <ImageColorIndicator> {
TypedValue = ImageColorIndicator.FromKey(ushort.Parse(numberValue))
});
case "backgroundcolorindicator":
return(new Tag <BackgroundColorIndicator> {
TypedValue = BackgroundColorIndicator.FromKey(ushort.Parse(numberValue))
});
case "hcusage":
return(new Tag <HCUsage> {
TypedValue = HCUsage.FromKey(ushort.Parse(numberValue))
});
case "exposureprogram":
return(new Tag <ExposureProgram> {
TypedValue = ExposureProgram.FromKey(ushort.Parse(numberValue))
});
case "sensitivitytype":
return(new Tag <SensitivityType> {
TypedValue = SensitivityType.FromKey(ushort.Parse(numberValue))
});
case "componentsconfiguration":
return(new Tag <ComponentsConfiguration> {
TypedValue = ComponentsConfiguration.FromKey(ushort.Parse(numberValue))
});
case "meteringmode":
return(new Tag <MeteringMode> {
TypedValue = MeteringMode.FromKey(ushort.Parse(numberValue))
});
case "lightsource":
case "calibrationilluminant1":
case "calibrationilluminant2":
return(new Tag <LightSource> {
TypedValue = LightSource.FromKey(ushort.Parse(numberValue))
});
case "flash":
return(new Tag <FlashValue> {
TypedValue = FlashValue.FromKey(ushort.Parse(numberValue))
});
case "focalplaneresolutionunit":
return(new Tag <FocalPlaneResolutionUnit> {
TypedValue = FocalPlaneResolutionUnit.FromKey(ushort.Parse(numberValue))
});
case "securityclassification":
return(new Tag <SecurityClassification> {
TypedValue = SecurityClassification.FromKey(numberValue)
});
case "sensingmethod":
return(new Tag <SensingMethod> {
TypedValue = SensingMethod.FromKey(ushort.Parse(numberValue))
});
case "colorspace":
return(new Tag <ColorSpace> {
TypedValue = ColorSpace.FromKey(ushort.Parse(numberValue))
});
case "filesource":
return(new Tag <FileSource> {
TypedValue = FileSource.FromKey(ushort.Parse(numberValue))
});
case "scenetype":
return(new Tag <SceneType> {
TypedValue = SceneType.FromKey(ushort.Parse(numberValue))
});
case "customrendered":
return(new Tag <CustomRendered> {
TypedValue = CustomRendered.FromKey(ushort.Parse(numberValue))
});
case "exposuremode":
return(new Tag <ExposureMode> {
TypedValue = ExposureMode.FromKey(ushort.Parse(numberValue))
});
case "whitebalance":
return(new Tag <WhiteBalance> {
TypedValue = WhiteBalance.FromKey(ushort.Parse(numberValue))
});
case "scenecapturetype":
return(new Tag <SceneCaptureType> {
TypedValue = SceneCaptureType.FromKey(ushort.Parse(numberValue))
});
case "gaincontrol":
return(new Tag <GainControl> {
TypedValue = GainControl.FromKey(ushort.Parse(numberValue))
});
case "contrast":
return(new Tag <Contrast> {
TypedValue = Contrast.FromKey(ushort.Parse(numberValue))
});
case "saturation":
return(new Tag <Saturation> {
TypedValue = Saturation.FromKey(ushort.Parse(numberValue))
});
case "sharpness":
return(new Tag <Sharpness> {
TypedValue = Sharpness.FromKey(ushort.Parse(numberValue))
});
case "subjectdistancerange":
return(new Tag <SubjectDistanceRange> {
TypedValue = SubjectDistanceRange.FromKey(ushort.Parse(numberValue))
});
case "pixelformat":
return(new Tag <PixelFormat> {
TypedValue = PixelFormat.FromKey(ushort.Parse(numberValue))
});
case "transformation":
return(new Tag <Transformation> {
TypedValue = Transformation.FromKey(ushort.Parse(numberValue))
});
case "uncompressed":
return(new Tag <Uncompressed> {
TypedValue = Uncompressed.FromKey(ushort.Parse(numberValue))
});
case "imagedatadiscard":
return(new Tag <ImageDataDiscard> {
TypedValue = ImageDataDiscard.FromKey(ushort.Parse(numberValue))
});
case "alphadatadiscard":
return(new Tag <AlphaDataDiscard> {
TypedValue = AlphaDataDiscard.FromKey(ushort.Parse(numberValue))
});
case "usptooriginalcontenttype":
return(new Tag <USPTOOriginalContentType> {
TypedValue = USPTOOriginalContentType.FromKey(ushort.Parse(numberValue))
});
case "cfalayout":
return(new Tag <CFALayout> {
TypedValue = CFALayout.FromKey(ushort.Parse(numberValue))
});
case "makernotesafety":
return(new Tag <MakerNoteSafety> {
TypedValue = MakerNoteSafety.FromKey(ushort.Parse(numberValue))
});
case "profileembedpolicy":
return(new Tag <ProfileEmbedPolicy> {
TypedValue = ProfileEmbedPolicy.FromKey(ushort.Parse(numberValue))
});
case "previewcolorspace":
return(new Tag <PreviewColorSpace> {
TypedValue = PreviewColorSpace.FromKey(ushort.Parse(numberValue))
});
case "profilehuesatmapencoding":
return(new Tag <ProfileHueSatMapEncoding> {
TypedValue = ProfileHueSatMapEncoding.FromKey(ushort.Parse(numberValue))
});
case "profilelooktableencoding":
return(new Tag <ProfileLookTableEncoding> {
TypedValue = ProfileLookTableEncoding.FromKey(ushort.Parse(numberValue))
});
case "defaultblackrender":
return(new Tag <DefaultBlackRender> {
TypedValue = DefaultBlackRender.FromKey(ushort.Parse(numberValue))
});
}
}
// ---- VALUE TAG ----
if (string.IsNullOrEmpty(info.ValueType))
{
return(new Tag());
}
switch (info.ValueType.ToLower())
{
case "int8u":
return(new Tag <byte> {
TypedValue = byte.Parse(numberValue)
});
case "int8s":
return(new Tag <sbyte> {
TypedValue = sbyte.Parse(numberValue)
});
case "int16u":
return(new Tag <ushort> {
TypedValue = ushort.Parse(numberValue)
});
case "int16s":
return(new Tag <short> {
TypedValue = short.Parse(numberValue)
});
case "int32u":
return(new Tag <uint> {
TypedValue = uint.Parse(numberValue)
});
case "integer":
case "int32s":
return(new Tag <int> {
TypedValue = int.Parse(numberValue)
});
case "int64u":
return(new Tag <ulong> {
TypedValue = ulong.Parse(numberValue)
});
case "int64s":
return(new Tag <long> {
TypedValue = long.Parse(numberValue)
});
case "float":
case "rational32s":
case "rational32u":
return(new Tag <float> {
TypedValue = float.Parse(numberValue)
});
case "double":
case "rational":
case "rational64s":
case "rational64u":
case "real":
return(new Tag <double> {
TypedValue = double.Parse(numberValue)
});
case "boolean":
return(new Tag <bool> {
TypedValue = bool.Parse(numberValue)
});
}
}
catch
{
if (!Quiet)
{
Console.WriteLine($"error converting {info.TableName}::{info.Id} with name {info.Name}. Expected type: {info.ValueType} but got value: {numberValue}");
}
}
return(new Tag());
}
protected async Task<byte[]> TakePictureInternal(Size liveViewImageStreamSize, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
return await Task.Run(() => Run(liveViewImageStreamSize, selectedAeMode, selectedAvValue, selectedIsoSensitivity, selectedShutterSpeed, selectedWhiteBalance, token), token);
}
private void SetCameraSettings(AEMode aeMode, WhiteBalance balance, ApertureValue apertureValue,
CameraISOSensitivity cameraIsoSensitivity, ShutterSpeed shutterSpeed)
{
_imageProcessor.SetSetting((uint)PropertyId.AEMode, (uint)aeMode);
_imageProcessor.SetSetting((uint)PropertyId.WhiteBalance, (uint)balance);
_imageProcessor.SetSetting((uint)PropertyId.Av, (uint)apertureValue);
//_imageProcessor.SetSetting((uint)PropertyId.ExposureCompensation, (uint)));
_imageProcessor.SetSetting((uint)PropertyId.ISOSpeed, (uint)cameraIsoSensitivity);
_imageProcessor.SetSetting((uint)PropertyId.Tv, (uint)shutterSpeed);
}
public static void SetWhiteBalance(Device devnum, WhiteBalance value)
{
throw new NotImplementedException("なにこれ");
}
public Hero3Camera WhiteBalance(WhiteBalance whiteBalance, bool nonBlocking = false)
{
return(ExecuteMultiChoiceCommand <CommandCameraWhiteBalance, WhiteBalance>(whiteBalance, nonBlocking));
}
public async Task SetWhiteBalanceAsync(WhiteBalance wb)
{
await NoValue(RequestGenerator.Jsonize("setWhiteBalance", wb.Mode, wb.ColorTemperature != WhiteBalance.InvalidColorTemperture, wb.ColorTemperature)).ConfigureAwait(false);
}
public Hero3Camera WhiteBalance(out WhiteBalance whiteBalance)
{
whiteBalance = base.ExtendedSettings().WhiteBalance;
return(this);
}
public async Task <Hero3Camera> WhiteBalanceAsync(WhiteBalance whiteBalance)
{
return(await base.PrepareCommand <CommandCameraWhiteBalance>().Select(whiteBalance).ExecuteAsync() as Hero3Camera);
}
protected async Task <byte[]> TakePictureInternal(Size liveViewImageStreamSize, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
return(await Task.Run(() => Run(liveViewImageStreamSize, selectedAeMode, selectedAvValue, selectedIsoSensitivity, selectedShutterSpeed, selectedWhiteBalance, token), token));
}
public override void ReadDeviceProperties(uint prop)
{
//lock (Locker)
//{
try
{
HaveLiveView = true;
switch (prop)
{
case CONST_PROP_Fnumber:
//FNumber.SetValue(_stillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_Fnumber));
ReInitFNumber(false);
break;
case CONST_PROP_MovieFnumber:
//FNumber.SetValue(_stillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_Fnumber));
ReInitFNumber(false);
break;
case CONST_PROP_ExposureIndex:
NormalIsoNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ExposureIndex), false);
break;
//case CONST_PROP_ExposureIndexEx:
// NormalIsoNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
// CONST_PROP_ExposureIndexEx), false);
// break;
case CONST_PROP_MovieExposureIndex:
MovieFNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_MovieExposureIndex), false);
break;
//case CONST_PROP_ExposureTime:
// NormalShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
// CONST_PROP_ExposureTime), false);
// break;
case CONST_PROP_ShutterSpeed:
NormalShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ShutterSpeed), false);
break;
case CONST_PROP_MovieShutterSpeed:
MovieShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_MovieShutterSpeed), false);
break;
case CONST_PROP_WhiteBalance:
WhiteBalance.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_WhiteBalance), false);
break;
case CONST_PROP_ExposureProgramMode:
Mode.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ExposureProgramMode), true);
break;
case CONST_PROP_ExposureBiasCompensation:
NormalExposureCompensation.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ExposureBiasCompensation),
false);
break;
case CONST_PROP_MovieExposureBiasCompensation:
MovieExposureCompensation.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_MovieExposureBiasCompensation),
false);
break;
case CONST_PROP_CompressionSetting:
CompressionSetting.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_CompressionSetting),
false);
break;
case CONST_PROP_ExposureMeteringMode:
ExposureMeteringMode.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ExposureMeteringMode),
false);
break;
case CONST_PROP_AFModeSelect:
NormalFocusMode.SetValue(
StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_AFModeSelect),
false);
NormalFocusMode.IsEnabled = NormalFocusMode.NumericValue != 3;
break;
case CONST_PROP_AfModeAtLiveView:
LiveViewFocusMode.SetValue(
StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_AfModeAtLiveView),
false);
LiveViewFocusMode.IsEnabled = LiveViewFocusMode.NumericValue != 3;
break;
case CONST_PROP_BatteryLevel:
{
var data = StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_BatteryLevel);
if (data.Data != null && data.Data.Length > 0)
{
Battery = data.Data[0];
}
}
break;
case CONST_PROP_ExposureIndicateStatus:
{
var data =
StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
CONST_PROP_ExposureIndicateStatus);
if (data.Data != null && data.Data.Length > 0)
{
sbyte i =
unchecked (
(sbyte)data.Data[0]);
ExposureStatus = Convert.ToInt32(i);
}
}
break;
case CONST_PROP_LiveViewStatus:
{
MTPDataResponse response = ExecuteReadDataEx(CONST_CMD_GetDevicePropValue, CONST_PROP_LiveViewStatus);
if (response.Data != null && response.Data.Length > 0)
{
LiveViewOn = response.Data[0] == 1;
}
else
{
LiveViewOn = false;
}
break;
}
case CONST_PROP_LiveViewSelector:
{
MTPDataResponse response = ExecuteReadDataEx(CONST_CMD_GetDevicePropValue, CONST_PROP_LiveViewSelector);
if (response.Data != null && response.Data.Length > 0)
{
LiveViewMovieOn = response.Data[0] == 1;
}
else
{
LiveViewMovieOn = false;
}
break;
}
default:
// imrovements from: http://digicamcontrol.com/forum/testingbug-reports/buglet-nikonbasecs
foreach (PropertyValue <long> advancedProperty in AdvancedProperties.Where(advancedProperty => advancedProperty.Code == prop))
{
if (advancedProperty.Name == "Image Size")
{
var val = StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
advancedProperty.Code);
if (val.Data != null && val.Data.Length > 0)
{
advancedProperty.SetValue(
Encoding.Unicode.GetString(val.Data, 1, 20), false);
}
}
else
{
advancedProperty.SetValue(
StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
advancedProperty.Code), false);
}
}
break;
}
}
catch (Exception ex)
{
Log.Error("ReadDeviceProperties error", ex);
}
//}
}
private async Task <byte[]> Run(Size liveViewImageStreamSize, AEMode selectedAeMode, ApertureValue selectedAvValue, CameraISOSensitivity selectedIsoSensitivity, ShutterSpeed selectedShutterSpeed, WhiteBalance selectedWhiteBalance, CancellationToken token)
{
var settings = GetCameraPhotoSettings();
var pictures = new List <byte[]>();
for (var i = 0; i < _pattern.Images.Count; i++)
{
token.ThrowIfCancellationRequested();
RaiseImageNumberChanged(i + 1);
RaiseTimerElapsed(4);
await Task.Delay(TimeSpan.FromSeconds(2), token);
for (var j = 3; j >= 0; j--)
{
RaiseTimerElapsed(j);
await Task.Delay(TimeSpan.FromSeconds(1), token);
}
SetCameraSettings(Enum.Parse(typeof(AEMode), settings.SelectedAeMode),
Enum.Parse(typeof(WhiteBalance), settings.SelectedWhiteBalance),
Enum.Parse(typeof(ApertureValue), settings.SelectedAvValue),
Enum.Parse(typeof(CameraISOSensitivity), settings.SelectedIsoSensitivity),
Enum.Parse(typeof(ShutterSpeed), settings.SelectedShutterSpeed));
//await Task.Delay(TimeSpan.FromSeconds(1));
//RaiseImageNumberChanged(i + 1);
//await Task.Delay(TimeSpan.FromSeconds(1), token);
token.ThrowIfCancellationRequested();
var picture = await _imageProcessor.DoTakePicture();
pictures.Add(picture);
token.ThrowIfCancellationRequested();
//await Task.Delay(TimeSpan.FromSeconds(3), token); //todo
SetCameraSettings(selectedAeMode, selectedWhiteBalance,
selectedAvValue, selectedIsoSensitivity,
selectedShutterSpeed);
StopLiveView();
StartLiveView();
}
var result = _imageUtils.ProcessImages(pictures, liveViewImageStreamSize, _pattern);
return(result);
}
public override bool Init(DeviceDescriptor deviceDescriptor)
{
IsBusy = false;
//the device not connected
try
{
ConnectToWiaDevice(deviceDescriptor);
}
catch (Exception exception)
{
Log.Error("Unable to connect camera using wia driver", exception);
return(false);
}
DeviceManager = new DeviceManager();
DeviceManager.RegisterEvent(Conts.wiaEventItemCreated, deviceDescriptor.WiaId);
DeviceManager.OnEvent += DeviceManager_OnEvent;
try
{
Device = deviceDescriptor.WiaDevice;
DeviceName = Device.Properties["Description"].get_Value();
Manufacturer = Device.Properties["Manufacturer"].get_Value();
SerialNumber = StaticHelper.GetSerial(Device.Properties["PnP ID String"].get_Value());
}
catch (Exception ex)
{
Log.Debug("Init error", ex);
}
IsConnected = true;
try
{
try
{
Property apertureProperty = Device.Properties[Conts.CONST_PROP_F_Number];
if (apertureProperty != null)
{
foreach (var subTypeValue in apertureProperty.SubTypeValues)
{
double d = (int)subTypeValue;
string s = (d / 100).ToString("0.0");
FNumber.AddValues(s, (int)d);
FNumber.ReloadValues();
if ((int)subTypeValue == (int)apertureProperty.get_Value())
{
FNumber.SetValue((int)d);
}
}
}
}
catch (COMException)
{
FNumber.IsEnabled = false;
}
try
{
Property isoProperty = Device.Properties[Conts.CONST_PROP_ISO_Number];
if (isoProperty != null)
{
foreach (var subTypeValue in isoProperty.SubTypeValues)
{
IsoNumber.AddValues(subTypeValue.ToString(), (int)subTypeValue);
IsoNumber.ReloadValues();
if ((int)subTypeValue == (int)isoProperty.get_Value())
{
IsoNumber.SetValue((int)subTypeValue);
}
}
}
}
catch (COMException)
{
IsoNumber.IsEnabled = false;
}
try
{
Property shutterProperty = Device.Properties[Conts.CONST_PROP_Exposure_Time];
if (shutterProperty != null)
{
foreach (int subTypeValue in shutterProperty.SubTypeValues)
{
if (ShutterTable.ContainsKey((int)subTypeValue))
{
ShutterSpeed.AddValues(ShutterTable[(int)subTypeValue], (int)subTypeValue);
}
}
ShutterSpeed.ReloadValues();
ShutterSpeed.SetValue(shutterProperty.get_Value());
}
}
catch (COMException)
{
ShutterSpeed.IsEnabled = false;
}
try
{
Property wbProperty = Device.Properties[Conts.CONST_PROP_WhiteBalance];
if (wbProperty != null)
{
foreach (var subTypeValue in wbProperty.SubTypeValues)
{
if (WbTable.ContainsKey((int)subTypeValue))
{
WhiteBalance.AddValues(WbTable[(int)subTypeValue], (int)subTypeValue);
}
}
WhiteBalance.ReloadValues();
WhiteBalance.SetValue(wbProperty.get_Value());
}
}
catch (COMException)
{
WhiteBalance.IsEnabled = false;
}
try
{
Property modeProperty = Device.Properties[Conts.CONST_PROP_ExposureMode];
if (modeProperty != null)
{
foreach (var subTypeValue in modeProperty.SubTypeValues)
{
if (ExposureModeTable.ContainsKey((int)subTypeValue))
{
Mode.AddValues(ExposureModeTable[(int)subTypeValue], Convert.ToUInt32(subTypeValue));
}
}
Mode.ReloadValues();
Mode.SetValue(Convert.ToUInt32(modeProperty.get_Value()));
}
Mode.IsEnabled = false;
}
catch (COMException)
{
Mode.IsEnabled = false;
}
try
{
Property ecProperty = Device.Properties[Conts.CONST_PROP_ExposureCompensation];
if (ecProperty != null)
{
foreach (var subTypeValue in ecProperty.SubTypeValues)
{
decimal d = (int)subTypeValue;
string s = decimal.Round(d / 1000, 1).ToString();
if (d > 0)
{
s = "+" + s;
}
ExposureCompensation.AddValues(s, (int)subTypeValue);
}
ExposureCompensation.ReloadValues();
ExposureCompensation.SetValue(ecProperty.get_Value());
}
}
catch (COMException)
{
ExposureCompensation.IsEnabled = false;
}
try
{
Property csProperty = Device.Properties[Conts.CONST_PROP_CompressionSetting];
if (csProperty != null)
{
foreach (var subTypeValue in csProperty.SubTypeValues)
{
if (CSTable.ContainsKey((int)subTypeValue))
{
CompressionSetting.AddValues(CSTable[(int)subTypeValue], (int)subTypeValue);
}
}
CompressionSetting.ReloadValues();
CompressionSetting.SetValue(csProperty.get_Value());
}
}
catch (COMException)
{
CompressionSetting.IsEnabled = false;
}
try
{
Property emmProperty = Device.Properties[Conts.CONST_PROP_ExposureMeteringMode];
if (emmProperty != null)
{
foreach (var subTypeValue in emmProperty.SubTypeValues)
{
if (EMMTable.ContainsKey((int)subTypeValue))
{
ExposureMeteringMode.AddValues(EMMTable[(int)subTypeValue], (int)subTypeValue);
}
}
ExposureMeteringMode.ReloadValues();
ExposureMeteringMode.SetValue(emmProperty.get_Value());
}
}
catch (COMException)
{
CompressionSetting.IsEnabled = false;
}
try
{
Property fmProperty = Device.Properties[Conts.CONST_PROP_FocusMode];
if (fmProperty != null)
{
foreach (int subTypeValue in fmProperty.SubTypeValues)
{
uint subval = Convert.ToUInt16(subTypeValue);
if (FMTable.ContainsKey(subval))
{
FocusMode.AddValues(FMTable[subval], subval);
}
}
FocusMode.ReloadValues();
FocusMode.SetValue(Convert.ToUInt16((int)fmProperty.get_Value()));
}
}
catch (COMException)
{
FocusMode.IsEnabled = false;
}
try
{
Battery = Device.Properties[Conts.CONST_PROP_BatteryStatus].get_Value();
}
catch (COMException)
{
Battery = 0;
}
IsConnected = true;
}
catch (Exception exception)
{
Log.Error(exception);
IsConnected = false;
}
HaveLiveView = true;
//Capabilities.Add(CapabilityEnum.LiveView);
return(true);
}
private void GetEvent()
{
try
{
var jString = Post(CreateJson("getEvent", "1.0", false));
var json = Initialize(jString);
var jResult = json["result"] as JArray;
if (jResult == null)
{
return;
}
var elem = jResult[2];
if (elem.HasValues)
{
LiveViewImageZoomRatio.SetValue(elem.Value <int>("zoomPositionCurrentBox").ToString(), false);
}
elem = jResult[5];
if (elem.HasValues)
{
foreach (var obj in elem.Children())
{
foreach (var u in obj["takePictureUrl"].Values <string>())
{
var url = u;
if (url.Contains("?"))
{
url = url.Split('?')[0];
}
PhotoCapturedEventArgs args = new PhotoCapturedEventArgs
{
WiaImageItem = null,
EventArgs = new PortableDeviceEventArgs(),
CameraDevice = this,
FileName = url.Replace('/', '\\'),
Handle = url
};
OnPhotoCapture(this, args);
}
}
}
elem = jResult[18];
if (elem.HasValues)
{
SetCapability(Mode, new Capability <string>
{
Current = elem.Value <string>("currentExposureMode"),
Candidates = elem["exposureModeCandidates"].Values <string>().ToList()
});
}
elem = jResult[27];
if (elem.HasValues)
{
SetCapability(FNumber, new Capability <string>
{
Current = elem.Value <string>("currentFNumber"),
Candidates = elem["fNumberCandidates"].Values <string>().ToList()
});
}
elem = jResult[28];
if (elem.HasValues)
{
SetCapability(FocusMode, new Capability <string>
{
Current = elem.Value <string>("currentFocusMode"),
Candidates = elem["focusModeCandidates"].Values <string>().ToList()
});
}
elem = jResult[29];
if (elem.HasValues)
{
SetCapability(IsoNumber, new Capability <string>
{
Current = elem.Value <string>("currentIsoSpeedRate"),
Candidates = elem["isoSpeedRateCandidates"].Values <string>().ToList()
});
}
elem = jResult[32];
if (elem.HasValues)
{
SetCapability(ShutterSpeed, new Capability <string>
{
Current = elem.Value <string>("currentShutterSpeed"),
Candidates = elem["shutterSpeedCandidates"].Values <string>().ToList()
});
}
elem = jResult[33];
if (elem.HasValues)
{
WhiteBalance.SetValue(elem.Value <string>("currentWhiteBalanceMode"), false);
}
if (jResult.Count > 36) // GetEvent version 1.2
{
elem = jResult[37];
if (elem.HasValues)
{
SetCapability(CompressionSetting, new Capability <string>
{
Current = elem.Value <string>("stillQuality"),
Candidates = elem["candidate"].Values <string>().ToList()
});
}
}
}
catch (Exception ex)
{
Log.Debug("Sony get error ", ex);
}
_timer.Start();
}
IEnumerator Transition(Vector3 startPos, Vector3 finalPos, Camera startCam, Camera endCam, VolumeProfile startProfile, VolumeProfile endProfile, Players endPlayer)
{
transitionVolume.enabled = true;
// Switch to more efficient method later
Bloom[] bloom = new Bloom[3];
ChromaticAberration[] chromaticAberration = new ChromaticAberration[3];
LensDistortion[] lensDistortion = new LensDistortion[3];
FilmGrain[] filmGrain = new FilmGrain[3];
ShadowsMidtonesHighlights[] shadowsMidtonesHighlights = new ShadowsMidtonesHighlights[3];
PaniniProjection[] paniniProjection = new PaniniProjection[3];
WhiteBalance[] whiteBalance = new WhiteBalance[3];
DepthOfField[] depthOfField = new DepthOfField[3];
Vignette[] vignette = new Vignette[3];
transitionVolume.profile.components.Clear();
foreach (VolumeComponent c in transitionStartProfile.components.AsReadOnly())
{
transitionVolume.profile.components.Add(c);
}
transitionVolume.profile.TryGet(out bloom[0]); transitionVolume.profile.TryGet(out chromaticAberration[0]); transitionVolume.profile.TryGet(out lensDistortion[0]); transitionVolume.profile.TryGet(out filmGrain[0]); transitionVolume.profile.TryGet(out shadowsMidtonesHighlights[0]); transitionVolume.profile.TryGet(out paniniProjection[0]); transitionVolume.profile.TryGet(out whiteBalance[0]); transitionVolume.profile.TryGet(out depthOfField[0]); transitionVolume.profile.TryGet(out vignette[0]);
startProfile.TryGet(out bloom[1]); startProfile.TryGet(out chromaticAberration[1]); startProfile.TryGet(out lensDistortion[1]); startProfile.TryGet(out filmGrain[1]); startProfile.TryGet(out shadowsMidtonesHighlights[1]); startProfile.TryGet(out paniniProjection[1]); startProfile.TryGet(out whiteBalance[1]); startProfile.TryGet(out depthOfField[1]); startProfile.TryGet(out vignette[1]);
endProfile.TryGet(out bloom[2]); endProfile.TryGet(out chromaticAberration[2]); endProfile.TryGet(out lensDistortion[2]); endProfile.TryGet(out filmGrain[2]); endProfile.TryGet(out shadowsMidtonesHighlights[2]); endProfile.TryGet(out paniniProjection[2]); endProfile.TryGet(out whiteBalance[2]); endProfile.TryGet(out depthOfField[2]); endProfile.TryGet(out vignette[2]);
for (float i = 0; i < Mathf.PI; i += weightTransferIncrement)
{
float weight = Mathf.Cos(i + Mathf.PI) / 2 + 0.5f;
transitionVolume.weight = Blend(0, 1, weight);
yield return(new WaitForEndOfFrame());
}
for (float i = 0; i < Mathf.PI; i += increment)
{
float weight = Mathf.Cos(i + Mathf.PI) / 2 + 0.5f;
transitionTransform.position = new Vector3(Blend(startPos.x, finalPos.x, weight), Blend(startPos.y, finalPos.y, weight), Blend(startPos.z, finalPos.z, weight));
transitionCamera.transform.rotation = Quaternion.Lerp(startCam.transform.rotation, endCam.transform.rotation, i / Mathf.PI);
transitionCamera.fieldOfView = Blend(startCam.fieldOfView, endCam.fieldOfView, weight);
// Bloom
bloom[0].threshold.value = Blend(bloom[1].threshold.value, bloom[2].threshold.value, weight);
bloom[0].intensity.value = Blend(bloom[1].intensity.value, bloom[2].intensity.value, weight);
bloom[0].tint.value = Color.Lerp(bloom[1].tint.value, bloom[2].tint.value, weight / Mathf.PI);
// Chromatic Aberration
chromaticAberration[0].intensity.value = Blend(chromaticAberration[1].intensity.value, chromaticAberration[2].intensity.value, weight);
// Lens Distortion
lensDistortion[0].intensity.value = Blend(lensDistortion[1].intensity.value, lensDistortion[2].intensity.value, weight);
// Film Grain
filmGrain[0].intensity.value = Blend(filmGrain[1].intensity.value, filmGrain[2].intensity.value, weight);
filmGrain[0].response.value = Blend(filmGrain[1].response.value, filmGrain[2].response.value, weight);
// Shadows Midtones and Highlights
shadowsMidtonesHighlights[0].shadows.value = Vector4.Lerp(shadowsMidtonesHighlights[1].shadows.value, shadowsMidtonesHighlights[2].shadows.value, weight / Mathf.PI);
shadowsMidtonesHighlights[0].midtones.value = Vector4.Lerp(shadowsMidtonesHighlights[1].midtones.value, shadowsMidtonesHighlights[2].midtones.value, weight / Mathf.PI);
shadowsMidtonesHighlights[0].highlights.value = Vector4.Lerp(shadowsMidtonesHighlights[1].highlights.value, shadowsMidtonesHighlights[2].highlights.value, weight / Mathf.PI);
shadowsMidtonesHighlights[0].shadowsStart.value = Blend(shadowsMidtonesHighlights[1].shadowsStart.value, shadowsMidtonesHighlights[2].shadowsStart.value, weight);
shadowsMidtonesHighlights[0].shadowsEnd.value = Blend(shadowsMidtonesHighlights[1].shadowsEnd.value, shadowsMidtonesHighlights[2].shadowsEnd.value, weight);
// Panini Projection
paniniProjection[0].distance.value = Blend(paniniProjection[1].distance.value, paniniProjection[2].distance.value, weight);
paniniProjection[0].cropToFit.value = Blend(paniniProjection[1].cropToFit.value, paniniProjection[2].cropToFit.value, weight);
// White Balance
whiteBalance[0].temperature.value = Blend(whiteBalance[1].temperature.value, whiteBalance[2].temperature.value, weight);
whiteBalance[0].tint.value = Blend(whiteBalance[1].tint.value, whiteBalance[2].tint.value, weight);
// Depth of Field
depthOfField[0].mode.value = depthOfField[2].mode.value;
depthOfField[0].gaussianStart.value = Blend(depthOfField[1].gaussianStart.value, depthOfField[2].gaussianStart.value, weight);
depthOfField[0].gaussianEnd.value = Blend(depthOfField[1].gaussianEnd.value, depthOfField[2].gaussianEnd.value, weight);
depthOfField[0].focusDistance.value = Blend(depthOfField[1].focusDistance.value, depthOfField[2].focusDistance.value, weight);
depthOfField[0].focalLength.value = Blend(depthOfField[1].focalLength.value, depthOfField[2].focalLength.value, weight);
depthOfField[0].aperture.value = Blend(depthOfField[1].aperture.value, depthOfField[2].aperture.value, weight);
depthOfField[0].bladeCount.value = (int)Blend(depthOfField[1].bladeCount.value, depthOfField[2].bladeCount.value, weight);
depthOfField[0].bladeCurvature.value = Blend(depthOfField[1].bladeCurvature.value, depthOfField[2].bladeCurvature.value, weight);
depthOfField[0].bladeRotation.value = Blend(depthOfField[1].bladeRotation.value, depthOfField[2].bladeRotation.value, weight);
// Vignette
vignette[0].color.value = Color.Lerp(vignette[1].color.value, vignette[2].color.value, Mathf.PI / weight);
vignette[0].intensity.value = Blend(vignette[1].intensity.value, vignette[2].intensity.value, weight);
vignette[0].smoothness.value = Blend(vignette[1].smoothness.value, vignette[2].smoothness.value, weight);
yield return(new WaitForEndOfFrame());
}
for (float i = 0; i < Mathf.PI; i += weightTransferIncrement)
{
float weight = Mathf.Cos(i + Mathf.PI) / 2 + 0.5f;
transitionVolume.weight = Blend(1, 0, weight);
yield return(new WaitForEndOfFrame());
}
EndTransition();
yield break;
}
public override int GetHashCode()
{
int hash = 1;
if (CameraDev.Length != 0)
{
hash ^= CameraDev.GetHashCode();
}
if (FrameId.Length != 0)
{
hash ^= FrameId.GetHashCode();
}
if (PixelFormat.Length != 0)
{
hash ^= PixelFormat.GetHashCode();
}
if (IoMethod != 0)
{
hash ^= IoMethod.GetHashCode();
}
if (Width != 0)
{
hash ^= Width.GetHashCode();
}
if (Height != 0)
{
hash ^= Height.GetHashCode();
}
if (FrameRate != 0)
{
hash ^= FrameRate.GetHashCode();
}
if (Monochrome != false)
{
hash ^= Monochrome.GetHashCode();
}
if (Brightness != 0)
{
hash ^= Brightness.GetHashCode();
}
if (Contrast != 0)
{
hash ^= Contrast.GetHashCode();
}
if (Saturation != 0)
{
hash ^= Saturation.GetHashCode();
}
if (Sharpness != 0)
{
hash ^= Sharpness.GetHashCode();
}
if (Gain != 0)
{
hash ^= Gain.GetHashCode();
}
if (AutoFocus != false)
{
hash ^= AutoFocus.GetHashCode();
}
if (Focus != 0)
{
hash ^= Focus.GetHashCode();
}
if (AutoExposure != false)
{
hash ^= AutoExposure.GetHashCode();
}
if (Exposure != 0)
{
hash ^= Exposure.GetHashCode();
}
if (AutoWhiteBalance != false)
{
hash ^= AutoWhiteBalance.GetHashCode();
}
if (WhiteBalance != 0)
{
hash ^= WhiteBalance.GetHashCode();
}
if (BytesPerPixel != 0)
{
hash ^= BytesPerPixel.GetHashCode();
}
if (TriggerInternal != 0)
{
hash ^= TriggerInternal.GetHashCode();
}
if (TriggerFps != 0)
{
hash ^= TriggerFps.GetHashCode();
}
if (ChannelName.Length != 0)
{
hash ^= ChannelName.GetHashCode();
}
if (DeviceWaitMs != 0)
{
hash ^= DeviceWaitMs.GetHashCode();
}
if (SpinRate != 0)
{
hash ^= SpinRate.GetHashCode();
}
if (OutputType != 0)
{
hash ^= OutputType.GetHashCode();
}
if (compressConf_ != null)
{
hash ^= CompressConf.GetHashCode();
}
return(hash);
}