// Assign this data to an orthographic camera.
public void AssignTo(Camera cam)
{
// Move the camera to the new 2D position without modifying the camera z position.
cam.transform.position = Swizzle.Vec3(position, "xy_", cam.transform.position);
cam.orthographicSize = orthographicSize;
cam.aspect = aspect;
}
public static void Initialize()
{
var args = NSProcessInfo.ProcessInfo.Arguments;
if (args.Contains("-doNotThrowOnInitFailure"))
{
ObjCRuntime.Class.ThrowOnInitFailure = false;
}
// Troubleshooting NSUrl crashes
if (args.Contains("-wrapNSUrlInitWithString"))
{
urlSwizzle = new Swizzle <InitWithStringDelegate>(new Class("NSURL"), Selector.GetHandle("initWithString:"), NSUrlInitWithString);
}
//urlSwizzle = new Swizzle<InitWithStringDelegate>(typeof(NSUrl), "initWithString:", NSUrlInitWithString);
if (args.Contains("-wrapNSDictionaryInitWithObjectsForKeysCount"))
{
initDictSwizzle = new Swizzle <InitDictWithObjectsForKeysCountDelegate>(typeof(NSDictionary), "dictionaryWithObjects:forKeys:count:", InitDictWithObjectsForKeysCount, true);
}
//-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:] + 53
if (args.Contains("-wrapConnectionWillSendRequestRedirectResponse"))
{
connectionSwizzle = new Swizzle <ConnectionWillSendRequestRedirectResponseDelegate>(new Class("WebCoreResourceHandleAsOperationQueueDelegate"), Selector.GetHandle("connection:willSendRequest:redirectResponse:"), ConnectionWillSendRequestRedirectResponse);
}
}
private static string MaskVector(Swizzle[] swizzle, string[] mask)
{
Contract.Requires <ArgumentNullException>(swizzle != null);
Contract.Requires <ArgumentException>(swizzle.Length > 0);
Contract.Requires <ArgumentNullException>(mask != null);
string s = string.Empty;
for (int i = 0; i < swizzle.Length; i++)
{
Swizzle component = swizzle[i];
if (component != Swizzle.Null)
{
s += component.ToString().ToLowerInvariant();
if (i + 1 < swizzle.Length - 2 && swizzle[i + 1] == Swizzle.Null)
{
s += ", ";
}
}
else
{
if (i > 0)
{
s += ", ";
}
s += mask[i];
}
}
return(s);
}
public static dynamic Swizzle(this Vect2f v)
{
var s = new Swizzle <float>();
s.Add('X', v.X);
s.Add('Y', v.Y);
return(s);
}
public static dynamic Swizzle(this Vect3 v)
{
var s = new Swizzle <double>();
s.Add('X', v.X);
s.Add('Y', v.Y);
s.Add('Z', v.Z);
return(s);
}
public virtual void WriteSwizzle(Swizzle s, ExpressionUsage u)
{
WriteMemberBase(s.Object);
foreach (var f in s.Fields)
{
WriteName(f);
}
}
public static NSApplication CreateShared()
{
if (instance == null)
{
instance = CreateFromInfoPlist() ?? new MonoApplication(New(typeof(MonoApplication)));
shared = new Swizzle <CreateSharedApplicationDelegate>(typeof(NSApplication), "sharedApplication", GetSharedApplication, true);
}
return(instance);
}
void SwizzleDict()
{
var selName = "initWithObjects:forKeys:";
using (swizzle = new Swizzle <NativeEventHandler>(typeof(NSDictionary), selName, HijackedInitWithObjectsForKeys))
{
var type = typeof(NSDictionary);
var d = new NSDictionary((NSString)"key1", (NSString)"obj1", (NSString)"key2", (NSString)"obj2");
}
}
private IImageSwizzle GetSwizzle()
{
if (Swizzle == null)
{
return(null);
}
var props = Swizzle.GetType().GetProperties();
var swizzleProp = props.FirstOrDefault(x => x.PropertyType == typeof(IImageSwizzle));
return((IImageSwizzle)swizzleProp?.GetValue(Swizzle));
}
public void InPlaceConstruction <T, TProperty>(T t1, T t2, Expression <Func <T, TProperty> > getXExpr, Expression <Func <T, TProperty> > getYExpr, TProperty x, TProperty y)
{
var t2_xy = new Swizzle <T, TProperty>(t2, getXExpr, getYExpr);
var t1_yx = new Swizzle <T, TProperty>(t1, getYExpr, getXExpr);
t2 = t2_xy.Set(t1_yx);
Func <T, TProperty> getX = getXExpr.Compile();
Func <T, TProperty> getY = getYExpr.Compile();
AssertHelper(getX(t1), getY(t1), getX(t2), getY(t2), x, y);
}
void SwizzleCls()
{
var selName = "dictionaryWithObjects:forKeys:count:";
using (swizzleCls = new Swizzle <NativeEventHandlerCls>(typeof(NSDictionary), selName, HijackedDictionaryWithObjectsForKeysCount, true))
{
var classHandle = Class.GetHandle(typeof(NSDictionary));
var keys = IntPtr.Zero;
var objects = IntPtr.Zero;
var sel = new Selector(selName);
var instanceHandle = MacApi.LibObjc.IntPtr_objc_msgSend_IntPtr_IntPtr_Int32(classHandle, sel.Handle, IntPtr.Zero, IntPtr.Zero, 0);
}
}
public static byte[] DecodeTexture(this ITexture texture)
{
byte[] decoded = null;
switch (texture.Format)
{
case TextureFormat.BC1 when texture is Xbx.Textures.MtxtTexture tex:
Xbx.Textures.Swizzle.Deswizzle(tex, 6);
decoded = Dxt.DecompressDxt1(texture);
break;
case TextureFormat.BC1:
Swizzle.Deswizzle(texture, 3);
decoded = Dxt.DecompressDxt1(texture);
break;
case TextureFormat.BC3 when texture is Xbx.Textures.MtxtTexture tex:
Xbx.Textures.Swizzle.Deswizzle(tex, 7);
decoded = Dxt.DecompressDxt5(texture);
break;
case TextureFormat.BC3:
Swizzle.Deswizzle(texture, 4);
decoded = Dxt.DecompressDxt5(texture);
break;
case TextureFormat.BC4:
Swizzle.Deswizzle(texture, 3);
decoded = Dxt.DecompressDxt4(texture);
break;
case TextureFormat.BC6H_UF16:
Swizzle.Deswizzle(texture, 4);
decoded = Dxt.DecompressBc6(texture);
break;
case TextureFormat.BC7:
Swizzle.Deswizzle(texture, 4);
decoded = Dxt.DecompressBc7(texture);
break;
case TextureFormat.R8G8B8A8_UNORM:
Swizzle.Deswizzle(texture, 4, 1);
decoded = texture.Data;
break;
}
return(decoded);
}
public static DDSEncoderResult EncodeTex(DDSLoadResult img)
{
var numMips = 1;
var alignment = 512;
var fmt = EncoderTable[img.Format];
var blockHeight = Utils.getBlockHeight(Utils.DIV_ROUND_UP(img.height, fmt.blkHeight));
var blockHeightLog2 = Utils.Log2(blockHeight);
var linesPerBlockHeight = blockHeight * 8;
var surfSize = 0;
var blockHeightShift = 0;
List <int> mipOfsets = new List <int>();
List <byte> res = new List <byte>();
for (int mipLevel = 0; mipLevel < numMips; mipLevel++)
{
var offSize = getCurrentMipOffset_Size(img.width, img.height, fmt.blkWidth, fmt.blkHeight, fmt.bpp, mipLevel);
byte[] data = new byte[offSize.Item2];
Array.Copy(img.data, offSize.Item1, data, 0, offSize.Item2);
var width_ = Math.Max(1, img.width >> mipLevel);
var height_ = Math.Max(1, img.height >> mipLevel);
var width__ = Utils.DIV_ROUND_UP(width_, fmt.blkWidth);
var height__ = Utils.DIV_ROUND_UP(height_, fmt.blkHeight);
int dataAlignBytes = Utils.round_up(surfSize, alignment) - surfSize;
surfSize += dataAlignBytes;
mipOfsets.Add(surfSize);
if (Utils.pow2_round_up(height__) < linesPerBlockHeight)
{
blockHeightShift += 1;
}
var pitch = Utils.round_up(width__ * fmt.bpp, 64);
surfSize += pitch * Utils.round_up(height__, Math.Max(1, blockHeight >> blockHeightShift) * 8);
if (dataAlignBytes != 0)
{
res.AddRange(new byte[dataAlignBytes]);
}
res.AddRange(Swizzle.swizzle(width_, height_, fmt.blkWidth, fmt.blkHeight, true, fmt.bpp, 0, Math.Max(0, blockHeightLog2 - blockHeightShift), data, true));
}
return(new DDSEncoderResult {
Data = res.ToArray(), blockHeightLog2 = blockHeightLog2, format = fmt
});
}
public static Expression TransformSwizzleToNewObject(this Swizzle s, Namescope scope)
{
// a.XYZ -> (temp = a, new T(temp.X, temp.Y, temp.Z))
// OR new T(a.X, a.Y, a.Z)
var obj = s.Object;
var ind = TryCreateIndirection(scope, ref obj);
var args = new Expression[s.Fields.Length];
for (int i = 0; i < s.Fields.Length; i++)
{
args[i] = new LoadField(s.Source, obj, s.Fields[i]);
}
var result = new NewObject(s.Source, s.Constructor, args);
return(ind != null
? (Expression) new SequenceOp(ind, result)
: result);
}
public static Vector2 Swizzle2(this Vector4 input, Swizzle swizzle) {
float[] data = Swizzle(new float[] { input.x, input.y, input.z, input.w }, TranslateCommonSwizzle(swizzle));
return new Vector2(data[0], data[1]);
}
public static Vector3 Swizzle3(this Vector2 input, Swizzle swizzle) {
float[] data = Swizzle(new float[] { input.x, input.y }, TranslateCommonSwizzle(swizzle));
return new Vector3(data[0], data[1], data[2]);
}
public void Read(BinaryReader _R)
{
m_layout = (Layout)_R.ReadUInt32();
m_type = (Type)_R.ReadUInt32();
m_swizzle = (Swizzle)_R.ReadUInt32();
}
public static Vector4 Swizzle4(this Vector3 input, Swizzle swizzle) {
float[] data = Swizzle(new float[] { input.x, input.y, input.z }, TranslateCommonSwizzle(swizzle));
return new Vector4(data[0], data[1], data[2], data[3]);
}
private static string TranslateCommonSwizzle(Swizzle swizzle) {
return _commonSwizzles[(int)swizzle];
}
/// <inheritdoc cref="IImageSwizzle.Get(Point)"/> public Point Get(Point point) => Swizzle.Get(point.Y * Width + point.X);
public void Read( BinaryReader _R )
{
m_layout = (Layout) _R.ReadUInt32();
m_type = (Type) _R.ReadUInt32();
m_swizzle = (Swizzle) _R.ReadUInt32();
}
/// <inheritdoc /> public Point Transform(Point point) => Swizzle.Get(point.Y * Width + point.X);