public static MapRepresentation Create(HttpRequestMessage req, IList<ContextSurface> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
OptionalProperty[] memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToArray();
INakedObjectSurface target = contexts.First().Target;
MapRepresentation mapRepresentation;
if (format == Format.Full) {
var tempProperties = new List<OptionalProperty>();
if (flags.SimpleDomainModel) {
var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName());
tempProperties.Add(dt);
}
if (flags.FormalDomainModel) {
var links = new OptionalProperty(JsonPropertyNames.Links, new[] {
Create(new OptionalProperty(JsonPropertyNames.Rel, RelValues.DescribedBy),
new OptionalProperty(JsonPropertyNames.Href, new UriMtHelper(req, target.Specification).GetDomainTypeUri()))
});
tempProperties.Add(links);
}
var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues));
tempProperties.Add(members);
mapRepresentation = Create(tempProperties.ToArray());
}
else {
mapRepresentation = Create(memberValues);
}
mapRepresentation.SetContentType(mt);
return mapRepresentation;
}
public static MapRepresentation Create(HttpRequestMessage req, ContextSurface context, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
var objectContextSurface = context as ObjectContextSurface;
var actionResultContextSurface = context as ActionResultContextSurface;
MapRepresentation mapRepresentation;
if (objectContextSurface != null) {
List<OptionalProperty> optionalProperties = objectContextSurface.VisibleProperties.Where(p => p.Reason != null || p.ProposedValue != null).Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToList();
if (!string.IsNullOrEmpty(objectContextSurface.Reason)) {
optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, objectContextSurface.Reason));
}
mapRepresentation = Create(optionalProperties.ToArray());
}
else if (actionResultContextSurface != null) {
List<OptionalProperty> optionalProperties = actionResultContextSurface.ActionContext.VisibleParameters.Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToList();
if (!string.IsNullOrEmpty(actionResultContextSurface.Reason)) {
optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, actionResultContextSurface.Reason));
}
mapRepresentation = Create(optionalProperties.ToArray());
}
else {
mapRepresentation = GetMap(req, context, flags);
}
mapRepresentation.SetContentType(mt);
return mapRepresentation;
}
void OnGUI()
{
GUILayout.BeginHorizontal();
GUI.enabled = m_Format != Format.Pretty;
if( GUILayout.Button ("PrettyFormat") )
{
m_Format = Format.Pretty;
}
GUI.enabled = m_Format != Format.Plain;
if( GUILayout.Button ("Plain Format") )
{
m_Format = Format.Plain;
}
GUILayout.EndHorizontal();
GUI.enabled = true;
if( GUILayout.Button("Serialize", GUILayout.Height (100)) )
{
_TestSerialInfo();
}
m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, GUILayout.Width (Screen.width-200));
if( m_str1.Length > 0)
{
GUILayout.TextArea(m_str1);
}
GUILayout.EndScrollView();
}
public void Init(
string name,
int width,
int height,
Format resourceFormat,
Format srvFormat,
BindFlags bindFlags,
int samplesCount,
int samplesQuality,
ResourceOptionFlags roFlags,
ResourceUsage ru,
int mipmapLevels,
CpuAccessFlags cpuAccessFlags)
{
m_name = name;
m_size = new Vector2I(width, height);
m_resourceFormat = resourceFormat;
m_srvFormat = srvFormat;
m_bindFlags = bindFlags;
m_samplesCount = samplesCount;
m_samplesQuality = samplesQuality;
m_roFlags = roFlags;
m_resourceUsage = ru;
m_mipmapLevels = mipmapLevels;
m_cpuAccessFlags = cpuAccessFlags;
}
public DataBuffer CreateIndexBuffer(int length, Usage usage, Format format, Pool pool)
{
IntPtr pOut = IntPtr.Zero;
int res = Interop.Calli(comPointer, length, (int)usage, (int)format, (int)pool, (IntPtr)(void*)&pOut, IntPtr.Zero,(*(IntPtr**)comPointer)[27]);
if( res < 0 ) { throw new SharpDXException( res ); }
return new DataBuffer( pOut );
}
public void TestContainer(Format format, string expectedOutput)
{
var schema = new Scope();
schema.Element<Item>()
.Attributes()
.Add(x => x.Name)
.End()
.Init();
schema.Element<Container>()
.Elements()
.Add(x => x.Items)
.End()
.Init();
var container = new Container(new[] {new Item("a"), new Item("b")});
var output = schema.ToString(container, format);
Assert.AreEqual(expectedOutput, output);
var container2 = schema.Parse<Container>(output, format);
Assert.AreEqual(container.Items.Count, container2.Items.Count);
Assert.AreEqual(container.Items[0].Name, container2.Items[0].Name);
Assert.AreEqual(container.Items[1].Name, container2.Items[1].Name);
}
public D3D9DepthBuffer( PoolId poolId, D3DRenderSystem renderSystem,
Device creator, Surface depthBufferSurf,
Format fmt, int width, int height,
MultisampleType fsaa, int multiSampleQuality,
bool isManual) :
base(poolId, 0, width, height, (int)fsaa, "", isManual)
{
depthBuffer = depthBufferSurf;
this.creator = creator;
this.multiSampleQuality = multiSampleQuality;
d3dFormat = fmt;
this.renderSystem = renderSystem;
switch (fmt)
{
case Format.D16Lockable:
case Format.D15S1:
case Format.D16:
bitDepth = 16;
break;
case Format.D32:
case Format.D24S8:
case Format.D24X8:
case Format.D24X4S4:
case Format.D32Lockable:
case Format.D24SingleS8:
bitDepth = 32;
break;
}
}
public static byte[] Decompress(int width, int height, byte[] source, Format format)
{
using (var strm = new MemoryStream(source))
{
return Decompress(width, height, new BinaryReader(strm), format);
}
}
public Consumer(string host, string groupName, string instanceId, Format format, string offset = "smallest")
{
this.host = host;
this.groupName = groupName;
this.instanceId = instanceId;
this.format = format;
var contentType = "application/vnd.kafka.v1+json";
var data = new Dictionary<string, string>
{
{"name", instanceId},
{"format", format.ToString().ToLower()},
{"auto.offset.reset", offset}
};
try
{
var responseString = WebRequestHelper.Post(host, $"consumers/{groupName}", JsonConvert.SerializeObject(data),
contentType);
dynamic response = JsonConvert.DeserializeObject<dynamic>(responseString);
this.instanceId = response.instance_id.ToObject<string>();
baseUri = response.base_uri.ToObject<string>();
}
catch (Exception e)
{
// it means, that consumer with this name already exists
log.Warn(e.Message);
baseUri = $"{host}/consumers/{groupName}/instances/{instanceId}";
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VertexElement" /> struct.
/// </summary>
/// <param name="semanticName">Name of the semantic.</param>
/// <param name="semanticIndex">Index of the semantic.</param>
/// <param name="format">The format.</param>
/// <param name="alignedByteOffset">The aligned byte offset.</param>
public VertexElementAttribute(string semanticName, int semanticIndex, Format format, int alignedByteOffset = VertexElement.AppendAligned)
{
this.semanticName = semanticName;
this.semanticIndex = semanticIndex;
this.format = format;
this.alignedByteOffset = alignedByteOffset;
}
public static string GetContentType(Format formats)
{
switch (formats)
{
case Format.Soap11:
case Format.Soap12:
case Format.Xml:
return Xml;
case Format.Json:
return Json;
case Format.Jsv:
return JsvText;
case Format.Csv:
return Csv;
case Format.ProtoBuf:
return ProtoBuf;
case Format.MsgPack:
return MsgPack;
default:
return null;
}
}
public FormattingInfo(FormattingInfo parent, FormatDetails formatDetails, Format format, object currentValue)
{
this.Parent = parent;
CurrentValue = currentValue;
Format = format;
FormatDetails = formatDetails;
}
public ShaderResourceView ToTexture3D(Device graphicsDevice, Format format)
{
int sizeInBytes = sizeof(float) * width * height * depth;
DataStream stream = new DataStream(sizeInBytes, true, true);
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
for (int z = 0; z < depth; z++)
stream.Write(values[x, y, z]);
stream.Position = 0;
DataBox dataBox = new DataBox(sizeof(float) * width, sizeof(float) * width * height, stream);
Texture3DDescription description = new Texture3DDescription()
{
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Depth = depth,
Format = format,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
Width = width
};
Texture3D texture = new Texture3D(graphicsDevice, description, dataBox);
stream.Dispose();
return new ShaderResourceView(graphicsDevice, texture);
}
public Config(Writer writer, Format fmt, GetConfig get_new_config)
{
m_fmt = fmt;
m_get_new_config = get_new_config ?? no_new_config;
file = new VectFormatter(writer);
file.seperator = fmt.line_spacing > 0 ? "" : " ";
file.seperator_spacing = fmt.line_spacing;
file.footer_spacing = 1;
top_vect = new_vect(writer, fmt.format_vect, "#(", "TV");
vect = new_vect(writer, fmt.format_vect, "#(", "V");
vect_cdr = new_vect(writer, fmt.format_vect, " . #(", "-V");
cons = new_cons(writer, fmt.do_abbrev, true, "C");
top_cons = new_cons(writer, fmt.do_abbrev, true, "TC");
vect_cons = new_cons(writer, fmt.do_abbrev, fmt.format_vect, "VC");
head_cons = new_cons(writer, fmt.do_abbrev, fmt.format_head, "HC");
vect_cons_cdr = new_cons_cdr(writer, fmt.format_vect, fmt.dot_cdr, fmt.dot_nil, "-VC");
head_cons_cdr = new_cons_cdr(writer, fmt.format_head, fmt.dot_cdr, fmt.dot_nil, "-HC");
appl_cons_cdr = new_cons_cdr(writer, fmt.format_appl, fmt.dot_cdr, fmt.dot_nil, "-AC");
data_cons_cdr = new_cons_cdr(writer, fmt.format_data, fmt.dot_cdr, fmt.dot_nil, "-DC");
atom = new AtomFormatter(writer);
atom_cdr = new AtomFormatter(writer);
atom_cdr.header = " . ";
}
public DisplayMode EnumAdapterModes(int adapter, Format format, int mode)
{
DisplayMode modeRef = new DisplayMode();
int res = Interop.Calli(comPointer, adapter, (int)format, mode, (IntPtr)(void*)&modeRef,(*(IntPtr**)comPointer)[7]);
if( res < 0 ) { throw new SharpDXException( res ); }
return modeRef;
}
public BlurComponent(Device graphics, int size)
{
_graphics = graphics;
Dims = size;
Format = Format.A8R8G8B8;
_sampleOffsetsHoriz = new Vector4D[SampleCount];
_sampleOffsetsVert = new Vector4D[SampleCount];
_sampleWeightsHoriz = new float[SampleCount];
_sampleWeightsVert = new float[SampleCount];
int width = Dims - 5;
int height = Dims - 5;
SetBlurEffectParameters(1.0f / width, 0, ref _sampleOffsetsHoriz, ref _sampleWeightsHoriz);
SetBlurEffectParameters(0, 1.0f / height, ref _sampleOffsetsVert, ref _sampleWeightsVert);
_effect = new GaussianBlurEffect(_graphics);
OutputTexture = new Texture(_graphics, Dims, Dims, 1, Usage.RenderTarget, Format, Pool.Default);
_intermediateTexture = new Texture(_graphics, Dims, Dims, 1, Usage.RenderTarget, Format, Pool.Default);
_sprite = new Sprite(_graphics);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/// Static and helper functions
////////////////////////////////////////////////////////////////////////////////////////////////
public static bool Import(tk2dTileMap tileMap, Format format)
{
var importer = new Importer();
string ext = "";
switch (format)
{
case Format.TMX:
if (!importer.CheckZlib()) return false;
ext = "tmx";
break;
}
string path = EditorUtility.OpenFilePanel("Import tilemap", "", ext);
if (path.Length == 0)
return false;
string message = "";
switch (format)
{
case Format.TMX: message = importer.ImportTMX(path); break;
}
if (message.Length != 0)
{
EditorUtility.DisplayDialog("Tilemap failed to import", message, "Ok");
return false;
}
importer.PopulateTilemap(tileMap);
return true;
}
/// <summary>
/// Creates a new graphics resource.
/// </summary>
/// <param name="device">The graphics device to use.</param>
/// <param name="dimensions">The resource dimensions.</param>
/// <param name="format">The resource's DXGI format.</param>
/// <param name="renderTargetView">Whether to bind as RTV.</param>
/// <param name="shaderResourceView">Whether to bind as SRV.</param>
/// <param name="hasMipMaps">Whether to enable mip-maps for this texture.</param>
public GraphicsResource(Device device, Size dimensions, Format format, Boolean renderTargetView = true, Boolean shaderResourceView = true, Boolean hasMipMaps = false)
{
if ((!renderTargetView) && (!shaderResourceView))
throw new ArgumentException("The requested resource cannot be bound at all to the pipeline.");
if ((hasMipMaps) && ((!renderTargetView) || (!shaderResourceView)))
throw new ArgumentException("A resource with mipmaps must be bound as both input and output.");
BindFlags bindFlags = (renderTargetView ? BindFlags.RenderTarget : 0) | (shaderResourceView ? BindFlags.ShaderResource : 0);
ResourceOptionFlags optionFlags = (hasMipMaps ? ResourceOptionFlags.GenerateMipMaps : 0);
int mipLevels = (hasMipMaps ? MipLevels(dimensions) : 1);
Resource = new Texture2D(device, new Texture2DDescription()
{
Format = format,
BindFlags = bindFlags,
Width = dimensions.Width,
Height = dimensions.Height,
ArraySize = 1,
MipLevels = mipLevels,
OptionFlags = optionFlags,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
RTV = ( renderTargetView ? new RenderTargetView(device, Resource) : null);
SRV = (shaderResourceView ? new ShaderResourceView(device, Resource) : null);
}
/// <summary>Initializes a new instance of the <see cref="DisplayMode"/> class.</summary>
/// <param name="pixelFormat">The pixel format.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="refreshRate">The refresh rate.</param>
public DisplayMode(Format pixelFormat, int width, int height, Rational refreshRate)
{
this.pixelFormat = pixelFormat;
this.width = width;
this.height = height;
this.refreshRate = refreshRate;
}
public SqlUserDefinedTypeAttribute (Format f)
{
Format = f;
IsByteOrdered = false;
IsFixedLength = false;
MaxByteSize = MaxByteSizeValue;
}
public Statistic(string name, float value, Format f)
{
this.name = name;
Debug.Log("Real KDR: " + value);
switch(f){
case (Format.percentage) :
{
this.value = RoundFloat(value,2).ToString();
this.value = value*100 + "%";
break;
}
case (Format.ratio):
{
this.value = RoundFloat(value,2).ToString();
break;
}
case (Format.time) :
{
this.value = string.Format("{0}:{01:00}", (int)value / 60, (int)value % 60);
break;
}
case (Format.none) :
{
this.value = value.ToString();
break;
}
}
}
internal void Clear()
{
m_deviceContext.ClearState();
m_inputLayout = null;
m_primitiveTopology = PrimitiveTopology.Undefined;
m_indexBufferRef = null;
m_indexBufferFormat = Format.Unknown;
m_indexBufferOffset = 0;
for (int i = 0; i < m_vertexBuffers.Length; i++)
m_vertexBuffers[i] = null;
for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
m_vertexBuffersStrides[i] = 0;
m_blendState = null;
m_stencilRef = 0;
m_depthStencilState = null;
m_rtvsCount = 0;
for (int i = 0; i < m_rtvs.Length; i++)
m_rtvs[i] = null;
m_dsv = null;
m_rasterizerState = null;
m_scissorLeftTop = new Vector2I(-1, -1);
m_scissorRightBottom = new Vector2I(-1, -1);
m_viewport = default(RawViewportF);
m_targetBuffer = null;
m_targetOffsets = 0;
m_statistics.ClearStates++;
}
/// <summary>
/// Inflate the data with the given format stored in a buffer
/// </summary>
/// <param name="buffer">A view with the encoded data</param>
/// <param name="format">An inflated format object</param>
/// <returns>Return null, an ArrayList or a single value (ulong, long, float, Token or string)</returns>
internal static object Inflate(BufferView buffer, Format format)
{
ArrayList data = new ArrayList();
if (InflateData.ReadElement(buffer, data, format.Root).Length != 0)
throw new ArgumentException("Unable to read data in the given format");
return data.Count == 0 ? null : (data.Count == 1 ? data[0] : data);
}
/// <summary>
/// Gets the number of alpha channel bits.
/// </summary>
public static int GetAlphaChannelBits(Format format)
{
switch (format)
{
case Format.R8G8B8:
return 0;
case Format.A8R8G8B8:
return 8;
case Format.X8R8G8B8:
return 0;
case Format.R5G6B5:
return 0;
case Format.X1R5G5B5:
return 0;
case Format.A1R5G5B5:
return 1;
case Format.A4R4G4B4:
return 4;
case Format.R3G3B2:
return 0;
case Format.A8R3G3B2:
return 8;
case Format.X4R4G4B4:
return 0;
case Format.A2B10G10R10:
return 2;
case Format.A2R10G10B10:
return 2;
default:
return 0;
}
}
public ImageSurface (Format format, int width, int height)
{
surface = NativeMethods.cairo_image_surface_create (format, width, height);
lock (surfaces.SyncRoot){
surfaces [surface] = this;
}
}
public void EvaluateFormat(object current, Format format, ref bool handled, IOutput output, FormatDetails formatDetails)
{
if (format != null && format.HasNested) return;
var formatText = format != null ? format.Text : "";
TimeSpan fromTime;
if (current is TimeSpan)
{
fromTime = (TimeSpan)current;
}
else if (current is DateTime && formatText.StartsWith("timestring"))
{
formatText = formatText.Substring(10);
fromTime = DateTime.Now.Subtract((DateTime)current);
}
else
{
return;
}
var timeTextInfo = GetTimeTextInfo(formatDetails.Provider);
if (timeTextInfo == null)
{
return;
}
var formattingOptions = TimeSpanFormatOptionsConverter.Parse(formatText);
var timeString = TimeSpanUtility.ToTimeString(fromTime, formattingOptions, timeTextInfo);
output.Write(timeString, formatDetails);
handled = true;
}
public void SetIndexBuffer(Buffer indexBuffer, Format format, int offset)
{
DiagnosticUtilities.RaiseEvent(this, SettingIndexBuffer, DiagnosticUtilities.GetID(indexBuffer), format, offset);
if (format != Format.R16_UInt && format != Format.R32_UInt)
throw new ArgumentOutOfRangeException("format");
_indexBufferBinding = new IndexBufferBinding(indexBuffer, format, offset);
}
//-------------------------------------------------------------------
// Constructor
//-------------------------------------------------------------------
public DrawDevice()
{
m_hwnd = IntPtr.Zero;
m_pDevice = null;
m_pSwapChain = null;
m_d3dpp = null;
m_Data = IntPtr.Zero;
m_format = Format.X8R8G8B8;
m_width = 0;
m_height = 0;
m_lDefaultStride = 0;
m_PixelAR.Denominator = m_PixelAR.Numerator = 1;
m_rcDest = Rectangle.Empty;
VideoFormatDefs = new VideoFormatGUID[] {
new VideoFormatGUID(MFMediaType.RGB32, TransformImage_RGB32, ARGB32_To_RGB32),
new VideoFormatGUID(MFMediaType.RGB24, TransformImage_RGB24, ARGB32_To_RGB24),
new VideoFormatGUID(MFMediaType.YUY2, TransformImage_YUY2, ARGB32_To_YUY2),
new VideoFormatGUID(MFMediaType.NV12, TransformImage_NV12, ARGB32_To_NV12)
};
m_convertFn = null;
m_bmpconvertFn = null;
}
public D3DDevice(IntPtr windowPtr, bool bWindowed, long Width, long Height)
{
m_bWindowed = bWindowed;
m_Format = Find16BitMode();
PresentParameters presentParameters = new PresentParameters();
presentParameters.Windowed = m_bWindowed;
presentParameters.SwapEffect = SwapEffect.Discard;
presentParameters.BackBufferCount = 1;
presentParameters.PresentationInterval = PresentInterval.Immediate;
presentParameters.AutoDepthStencilFormat = DepthFormat.D16;
presentParameters.EnableAutoDepthStencil = true;
if(!bWindowed)
{
presentParameters.BackBufferFormat = m_Format;
presentParameters.BackBufferWidth = (int)Width;
presentParameters.BackBufferHeight = (int)Height;
}
else
{
presentParameters.BackBufferFormat = Format.Unknown;
presentParameters.BackBufferWidth = (int)Width;
presentParameters.BackBufferHeight = (int)Height;
}
m_D3DDevice = new Microsoft.DirectX.Direct3D.Device(0,
DeviceType.Hardware, windowPtr,
CreateFlags.SoftwareVertexProcessing, presentParameters);
}
public static int CompressedImageSize(Format format, int width, int height, int depth, int byteAlignment)
{
int rowPitch, slicePitch, totalSize;
switch (format)
{
case Format.CompressedRgbaS3tcDxt1Ext:
case Format.CompressedSrgbAlphaS3tcDxt1Ext:
case Format.CompressedRedRgtc1: // bc4
case Format.CompressedSignedRedRgtc1:
TextureHelper.GetInfoForSetDataCompressed(4, width, height, depth, byteAlignment, out rowPitch, out slicePitch, out totalSize);
return totalSize;
case Format.CompressedRgbaS3tcDxt3Ext:
case Format.CompressedSrgbAlphaS3tcDxt3Ext:
case Format.CompressedRgbaS3tcDxt5Ext:
case Format.CompressedSrgbAlphaS3tcDxt5Ext:
case Format.CompressedRgRgtc2:
case Format.CompressedSignedRgRgtc2:
case Format.CompressedRgbaBptcUf:
case Format.CompressedRgbaBptcSf:
case Format.CompressedRgbaBptc:
case Format.CompressedSrgbAlphaBptc:
TextureHelper.GetInfoForSetDataCompressed(8, width, height, depth, byteAlignment, out rowPitch, out slicePitch, out totalSize);
return totalSize;
default:
throw new InvalidOperationException(string.Format("Format '{0}' is not a known compressed format", format));
}
}
static IEnumerable <Color> GetColorsFromTexture(byte[] tex, Format format)
{
using (var br = new BinaryReaderX(new MemoryStream(tex)))
{
var etc1decoder = new Etc1.Decoder();
while (true)
{
int a = 255, r = 255, g = 255, b = 255;
switch (format)
{
case Format.L8:
b = g = r = br.ReadByte();
break;
case Format.A8:
a = br.ReadByte();
break;
case Format.LA44:
a = br.ReadNibble() * 17;
b = g = r = br.ReadNibble() * 17;
break;
case Format.LA88:
a = br.ReadByte();
b = g = r = br.ReadByte();
break;
case Format.HL88:
g = br.ReadByte();
r = br.ReadByte();
break;
case Format.RGB565:
var s = br.ReadUInt16();
b = (s % 32) * 33 / 4;
g = (s >> 5) % 64 * 65 / 16;
r = (s >> 11) * 33 / 4;
break;
case Format.RGB888:
b = br.ReadByte();
g = br.ReadByte();
r = br.ReadByte();
break;
case Format.RGBA5551:
var s2 = br.ReadUInt16();
a = (s2 & 1) * 255;
b = (s2 >> 1) % 32 * 33 / 4;
g = (s2 >> 6) % 32 * 33 / 4;
r = (s2 >> 11) % 32 * 33 / 4;
break;
case Format.RGBA4444:
a = br.ReadNibble() * 17;
b = br.ReadNibble() * 17;
g = br.ReadNibble() * 17;
r = br.ReadNibble() * 17;
break;
case Format.RGBA8888:
a = br.ReadByte();
b = br.ReadByte();
g = br.ReadByte();
r = br.ReadByte();
break;
case Format.ETC1:
case Format.ETC1A4:
yield return(etc1decoder.Get(() =>
{
var alpha = (format == Format.ETC1A4) ? br.ReadUInt64() : ulong.MaxValue;
return new Etc1.PixelData {
Alpha = alpha, Block = br.ReadStruct <Etc1.Block>()
};
}));
continue;
case Format.L4:
b = g = r = br.ReadNibble() * 17;
break;
case Format.A4:
a = br.ReadNibble() * 17;
break;
default:
throw new NotSupportedException($"Unknown image format {format}");
}
yield return(Color.FromArgb(a, r, g, b));
}
}
}
public async Task RemindInternal(ulong targetId, bool isPrivate, string timeStr, [Remainder] string message)
{
var m = _regex.Match(timeStr);
if (m.Length == 0)
{
await ReplyErrorLocalized("remind_invalid_format").ConfigureAwait(false);
return;
}
string output = "";
var namesAndValues = new Dictionary <string, int>();
foreach (var groupName in _regex.GetGroupNames())
{
if (groupName == "0")
{
continue;
}
int value;
int.TryParse(m.Groups[groupName].Value, out value);
if (string.IsNullOrEmpty(m.Groups[groupName].Value))
{
namesAndValues[groupName] = 0;
continue;
}
if (value < 1 ||
(groupName == "months" && value > 1) ||
(groupName == "weeks" && value > 4) ||
(groupName == "days" && value >= 7) ||
(groupName == "hours" && value > 23) ||
(groupName == "minutes" && value > 59))
{
await Context.Channel.SendErrorAsync($"Invalid {groupName} value.").ConfigureAwait(false);
return;
}
namesAndValues[groupName] = value;
output += m.Groups[groupName].Value + " " + groupName + " ";
}
var time = DateTime.Now + new TimeSpan(30 * namesAndValues["months"] +
7 * namesAndValues["weeks"] +
namesAndValues["days"],
namesAndValues["hours"],
namesAndValues["minutes"],
0);
var rem = new Reminder
{
ChannelId = targetId,
IsPrivate = isPrivate,
When = time,
Message = message,
UserId = Context.User.Id,
ServerId = Context.Guild.Id
};
using (var uow = DbHandler.UnitOfWork())
{
uow.Reminders.Add(rem);
await uow.CompleteAsync();
}
try
{
await Context.Channel.SendConfirmAsync(
"⏰ " + GetText("remind",
Format.Bold(!isPrivate ? $"<#{targetId}>" : Context.User.Username),
Format.Bold(message.SanitizeMentions()),
Format.Bold(output),
time, time)).ConfigureAwait(false);
}
catch
{
// ignored
}
await StartReminder(rem, cancelAllToken);
}
public async Task Google([Remainder] string terms = null)
{
terms = terms?.Trim();
if (string.IsNullOrWhiteSpace(terms))
{
return;
}
terms = WebUtility.UrlEncode(terms).Replace(' ', '+');
var fullQueryLink = $"https://www.google.ca/search?q={ terms }&gws_rd=cr,ssl&cr=countryUS";
var config = Configuration.Default.WithDefaultLoader();
using (var document = await BrowsingContext.New(config).OpenAsync(fullQueryLink))
{
var elems = document.QuerySelectorAll("div.g");
var resultsElem = document.QuerySelectorAll("#resultStats").FirstOrDefault();
var totalResults = resultsElem?.TextContent;
//var time = resultsElem.Children.FirstOrDefault()?.TextContent
//^ this doesn't work for some reason, <nobr> is completely missing in parsed collection
if (!elems.Any())
{
return;
}
var results = elems.Select <IElement, GoogleSearchResult?>(elem =>
{
var aTag = (elem.Children.FirstOrDefault()?.Children.FirstOrDefault() as IHtmlAnchorElement); // <h3> -> <a>
var href = aTag?.Href;
var name = aTag?.TextContent;
if (href == null || name == null)
{
return(null);
}
var txt = elem.QuerySelectorAll(".st").FirstOrDefault()?.TextContent;
if (txt == null)
{
return(null);
}
return(new GoogleSearchResult(name, href, txt));
}).Where(x => x != null).Take(5);
var embed = new EmbedBuilder()
.WithOkColor()
.WithAuthor(eab => eab.WithName(GetText("search_for") + " " + terms.TrimTo(50))
.WithUrl(fullQueryLink)
.WithIconUrl("http://i.imgur.com/G46fm8J.png"))
.WithTitle(Context.User.ToString())
.WithFooter(efb => efb.WithText(totalResults));
var desc = await Task.WhenAll(results.Select(async res =>
$"[{Format.Bold(res?.Title)}]({(await _google.ShortenUrl(res?.Link))})\n{res?.Text?.TrimTo(400 - res.Value.Title.Length - res.Value.Link.Length)}\n\n"))
.ConfigureAwait(false);
var descStr = string.Concat(desc);
_log.Info(descStr.Length);
await Context.Channel.EmbedAsync(embed.WithDescription(descStr)).ConfigureAwait(false);
}
}
public static uint GetD3DFormat(this Format f)
{
return(kXenonFormats[(int)f]);
}
public async Task Time([Remainder] string arg)
{
if (string.IsNullOrWhiteSpace(arg) || string.IsNullOrWhiteSpace(_creds.GoogleApiKey))
{
return;
}
var res = await _service.Http.GetStringAsync($"https://maps.googleapis.com/maps/api/geocode/json?address={arg}&key={_creds.GoogleApiKey}").ConfigureAwait(false);
var obj = JsonConvert.DeserializeObject <GeolocationResult>(res);
var currentSeconds = DateTime.UtcNow.UnixTimestamp();
var timeRes = await _service.Http.GetStringAsync($"https://maps.googleapis.com/maps/api/timezone/json?location={obj.results[0].Geometry.Location.Lat},{obj.results[0].Geometry.Location.Lng}×tamp={currentSeconds}&key={_creds.GoogleApiKey}").ConfigureAwait(false);
var timeObj = JsonConvert.DeserializeObject <TimeZoneResult>(timeRes);
var time = DateTime.UtcNow.AddSeconds(timeObj.DstOffset + timeObj.RawOffset);
await ReplyConfirmLocalized("time", Format.Bold(obj.results[0].FormattedAddress), Format.Code(time.ToString("HH:mm")), timeObj.TimeZoneName).ConfigureAwait(false);
}
/// <summary>
/// Ensures that the image bindings are visible to the host GPU.
/// Note: this actually performs the binding using the host graphics API.
/// </summary>
/// <param name="pool">The current texture pool</param>
/// <param name="stage">The shader stage using the textures to be bound</param>
/// <param name="stageIndex">The stage number of the specified shader stage</param>
private void CommitImageBindings(TexturePool pool, ShaderStage stage, int stageIndex)
{
if (_imageBindings[stageIndex] == null)
{
return;
}
// Scales for images appear after the texture ones.
int baseScaleIndex = _textureBindings[stageIndex]?.Length ?? 0;
for (int index = 0; index < _imageBindings[stageIndex].Length; index++)
{
TextureBindingInfo bindingInfo = _imageBindings[stageIndex][index];
int textureBufferIndex = bindingInfo.CbufSlot < 0 ? _textureBufferIndex : bindingInfo.CbufSlot;
int packedId = ReadPackedId(stageIndex, bindingInfo.Handle, textureBufferIndex);
int textureId = UnpackTextureId(packedId);
Texture texture = pool.Get(textureId);
ITexture hostTexture = texture?.GetTargetTexture(bindingInfo.Target);
bool isStore = bindingInfo.Flags.HasFlag(TextureUsageFlags.ImageStore);
if (hostTexture != null && texture.Target == Target.TextureBuffer)
{
// Ensure that the buffer texture is using the correct buffer as storage.
// Buffers are frequently re-created to accomodate larger data, so we need to re-bind
// to ensure we're not using a old buffer that was already deleted.
Format format = bindingInfo.Format;
if (format == 0 && texture != null)
{
format = texture.Format;
}
_context.Methods.BufferManager.SetBufferTextureStorage(hostTexture, texture.Range.GetSubRange(0).Address, texture.Size, bindingInfo, format, true);
}
else if (isStore)
{
texture?.SignalModified();
}
if (_imageState[stageIndex][index].Texture != hostTexture || _rebind)
{
if (UpdateScale(texture, bindingInfo, baseScaleIndex + index, stage))
{
hostTexture = texture?.GetTargetTexture(bindingInfo.Target);
}
_imageState[stageIndex][index].Texture = hostTexture;
Format format = bindingInfo.Format;
if (format == 0 && texture != null)
{
format = texture.Format;
}
_context.Renderer.Pipeline.SetImage(bindingInfo.Binding, hostTexture, format);
}
}
}
