private void BuildTexture(int width, int height)
{
// TODO: This should probably be a dynamic texture, with updates performed via mapping. Work it out.
texture = new D3D11.Texture2D(DxHandler.Device, new D3D11.Texture2DDescription()
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new DXGI.SampleDescription(1, 0),
Usage = D3D11.ResourceUsage.Default,
//Usage = D3D11.ResourceUsage.Dynamic,
BindFlags = D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
//CpuAccessFlags = D3D11.CpuAccessFlags.Write,
OptionFlags = D3D11.ResourceOptionFlags.None,
});
var view = new D3D11.ShaderResourceView(DxHandler.Device, texture, new D3D11.ShaderResourceViewDescription()
{
Format = texture.Description.Format,
Dimension = D3D.ShaderResourceViewDimension.Texture2D,
Texture2D = { MipLevels = texture.Description.MipLevels },
});
textureWrap = new D3DTextureWrap(view, texture.Description.Width, texture.Description.Height);
}
internal WebGLTexture(byte[] data, TextureType type,
int width, int height, int depth,
TextureFormat format,
TextureFilter minFilter, TextureFilter magFilter,
TextureWrap wrapX, TextureWrap wrapY)
{
Type = type;
Width = width;
Height = height;
Depth = depth;
Format = format;
id = GL.createTexture();
switch (Type)
{
case TextureType.Texture2D:
TextureTarget = GL.TEXTURE_2D;
break;
//case TextureType.Texture2DArray: // Not available in WebGL 1.0
// TextureTarget = GL.TEXTURE_2D_ARRAY;
// break;
//case TextureType.Texture3D: // Not available in WebGL 1.0
// TextureTarget = GL.TEXTURE_3D;
// break;
default:
throw new IllegalValueException(typeof(TextureType), Type);
}
MinFilter = minFilter;
MagFilter = magFilter;
WrapX = wrapX;
WrapY = wrapY;
SetData(data);
}
public Ring(TextureWrap image, float colorR = 1f, float colorG = 1f, float colorB = 1f, float alpha = 1f)
{
Image = image;
Color = new Vector3(colorR, colorG, colorB);
Alpha = alpha;
Flip = false;
}
public Sampler2d(Map2d map, TextureWrap wrapMode, FilteringType filtering = FilteringType.Best, bool useMipmaps = true)
{
this.Map = map;
this.Filtering = filtering;
this.WrapMode = wrapMode;
this.UseMipmaps = useMipmaps;
}
public void Initialize(DalamudPluginInterface pluginInterface)
{
_pi = pluginInterface;
Config = pluginInterface.GetPluginConfig() as CharacterSyncConfig ?? new CharacterSyncConfig();
_pi.UiBuilder.OnBuildUi += UiBuilder_OnBuildUi;
_pi.UiBuilder.OnOpenConfigUi += (sender, args) => _isMainConfigWindowDrawing = true;
_pi.CommandManager.AddHandler("/pcharsync",
new CommandInfo((string cmd, string args) => _isMainConfigWindowDrawing = true)
{
HelpMessage = "Open the Character Sync configuration."
});
this._createFileHook = new Hook <CreateFileWDelegate>(LocalHook.GetProcAddress("Kernel32", "CreateFileW"), new CreateFileWDelegate(CreateFileWDetour));
this._createFileHook.Enable();
if (pluginInterface.Reason == PluginLoadReason.Installer)
{
_isSafeMode = true;
PluginLog.Log("Installer, safe mode...");
}
if (pluginInterface.Reason == PluginLoadReason.Boot && pluginInterface.ClientState.LocalPlayer != null)
{
_isSafeMode = true;
_showRestartMessage = true;
_warningTex = pluginInterface.UiBuilder.LoadImage(Path.Combine(
Path.GetDirectoryName(Assembly.GetAssembly(typeof(CharacterSyncPlugin)).Location), "warningtex.png"));
PluginLog.Log("Boot while logged in, safe mode...");
}
}
private void DrawTex()
{
ImGui.InputText("Tex Path", ref this.inputTexPath, 255);
ImGui.InputFloat2("UV0", ref this.inputTexUv0);
ImGui.InputFloat2("UV1", ref this.inputTexUv1);
ImGui.InputFloat4("Tint", ref this.inputTintCol);
ImGui.InputFloat2("Scale", ref this.inputTexScale);
if (ImGui.Button("Load Tex"))
{
try
{
this.debugTex = this.dalamud.Data.GetImGuiTexture(this.inputTexPath);
this.inputTexScale = new Vector2(this.debugTex.Width, this.debugTex.Height);
}
catch (Exception ex)
{
Log.Error(ex, "Could not load tex.");
}
}
ImGuiHelpers.ScaledDummy(10);
if (this.debugTex != null)
{
ImGui.Image(this.debugTex.ImGuiHandle, this.inputTexScale, this.inputTexUv0, this.inputTexUv1, this.inputTintCol);
ImGuiHelpers.ScaledDummy(5);
Util.ShowObject(this.debugTex);
}
}
public void set(TextureDescriptor other)
{
texture = other.texture;
minFilter = other.minFilter;
magFilter = other.magFilter;
uWrap = other.uWrap;
vWrap = other.vWrap;
}
public void set(GLTexture texture, TextureFilter minFilter = TextureFilter.Linear, TextureFilter magFilter = TextureFilter.Linear, TextureWrap uWrap = TextureWrap.ClampToEdge, TextureWrap vWrap = TextureWrap.ClampToEdge)
{
this.texture = texture;
this.minFilter = minFilter;
this.magFilter = magFilter;
this.uWrap = uWrap;
this.vWrap = vWrap;
}
/// <summary>
/// Applies a texture wrap style to a given gl texture target
/// </summary>
public static void ApplyTextureWrap( int target, int dir, TextureWrap wrap )
{
switch ( wrap )
{
case TextureWrap.Repeat : Gl.glTexParameteri( target, dir, Gl.GL_REPEAT ); break;
case TextureWrap.Clamp : Gl.glTexParameteri( target, dir, Gl.GL_CLAMP ); break;
}
}
public void setWrap(TextureWrap u, TextureWrap v)
{
this.uWrap = u;
this.vWrap = v;
bind();
GL.TexParameter(glTarget, TextureParameterName.TextureWrapS, TextureHelper.getGLEnumFromTextureWrap(u));
GL.TexParameter(glTarget, TextureParameterName.TextureWrapT, TextureHelper.getGLEnumFromTextureWrap(v));
}
static void Init(SimpleImGuiScene scene)
{
ParseSongs("xiv_bgm.csv");
starImg = scene.LoadImage("favoriteIcon.png");
settingsImg = scene.LoadImage("settings.png");
scene.OnBuildUI += Display;
}
private void LoadStyle(string name, string path, bool isUserStyle)
{
var fileNames = new[]
{
"Bar.png",
"BarBG.png",
"Cast.png",
"CastBG.png"
};
if (isUserStyle ? UserStyles.ContainsKey(name) : Styles.ContainsKey(name))
{
return;
}
var images = new TextureWrap[4];
for (var i = 0; i != fileNames.Length; ++i)
{
var filePath = Path.Combine(path, $@"{name}\{fileNames[i]}");
if (!File.Exists(filePath))
{
foreach (var image in images)
{
image?.Dispose();
}
PluginLog.Error($"{filePath} was not found.");
return;
}
images[i] = PluginInterface.UiBuilder.LoadImage(filePath);
if (images[i] != null)
{
continue;
}
foreach (var image in images)
{
image?.Dispose();
}
PluginLog.Error($"Failed to load {filePath}.");
return;
}
if (isUserStyle)
{
UserStyles[name] = images;
}
else
{
Styles[name] = images;
}
}
public FileTextureProvider(TextureFilter minFilter, TextureFilter magFilter, TextureWrap uWrap,
TextureWrap vWrap, bool useMipMaps)
{
this.minFilter = minFilter;
this.magFilter = magFilter;
this.uWrap = uWrap;
this.vWrap = vWrap;
this.useMipMaps = useMipMaps;
}
public TextureSlot(Texture texture, int uvIndex, float blendFactor, TextureOperation operation, TextureWrap wrapS, TextureWrap wrapT)
{
this.Texture = texture;
this.UVIndex = uvIndex;
this.BlendFactor = blendFactor;
this.Operation = operation;
this.WrapS = wrapS;
this.WrapT = wrapT;
}
/// <summary>
/// Places an image at position relative to the base position of the attached interface object, while being able to define what part of the image to draw.
/// </summary>
/// <param name="image"></param>
/// <param name="size">(width, height)</param>
/// <param name="position">(top, left)</param>
/// <param name="imageArea">(left, top, width, height)</param>
public void DrawImage(ImDrawListPtr d, TextureWrap image, Vector2 size, Vector2 position, Vector4 imageArea)
{
var basePosition = ImGui.GetItemRectMin();
var imageWidth = image.Width;
var imageHeight = image.Height;
var finalPosition = basePosition + position;
d.AddImage(image.ImGuiHandle, finalPosition, finalPosition + size, finalPosition + new Vector2(imageArea.X / imageWidth, imageArea.Y / imageHeight), finalPosition + new Vector2((imageArea.X + imageArea.Z) / imageWidth,
(imageArea.Y + imageArea.W) / imageHeight));
}
public static Texture Create2DFromFile(string file,
TextureFormat format = DefaultFormat,
TextureFilter minFilter = DefaultMinFilter, TextureFilter magFilter = DefaultMagFilter,
TextureWrap wrapX = DefaultWrapX, TextureWrap wrapY = DefaultWrapY)
{
return(Graphics.CreateTexture2DFromFile(file,
format,
minFilter, magFilter,
wrapX, wrapY));
}
public AGSTextureConfig(ScaleDownFilters scaleDown = ScaleDownFilters.Nearest,
ScaleUpFilters scaleUp = ScaleUpFilters.Nearest,
TextureWrap wrapX = TextureWrap.Clamp,
TextureWrap wrapY = TextureWrap.Clamp)
{
ScaleDownFilter = scaleDown;
ScaleUpFilter = scaleUp;
WrapX = wrapX;
WrapY = wrapY;
}
public AGSTextureConfig(ScaleDownFilters scaleDown = ScaleDownFilters.Nearest,
ScaleUpFilters scaleUp = ScaleUpFilters.Nearest,
TextureWrap wrapX = TextureWrap.Clamp,
TextureWrap wrapY = TextureWrap.Clamp)
{
ScaleDownFilter = scaleDown;
ScaleUpFilter = scaleUp;
WrapX = wrapX;
WrapY = wrapY;
}
public SharedTextureHandler(TextureHandleResponse response)
{
var texture = DxHandler.Device.OpenSharedResource <D3D11.Texture2D>(response.TextureHandle);
var view = new D3D11.ShaderResourceView(DxHandler.Device, texture, new D3D11.ShaderResourceViewDescription()
{
Format = texture.Description.Format,
Dimension = D3D.ShaderResourceViewDimension.Texture2D,
Texture2D = { MipLevels = texture.Description.MipLevels },
});
textureWrap = new D3DTextureWrap(view, texture.Description.Width, texture.Description.Height);
}
public static Texture Create2D(byte[] data,
int width, int height,
TextureFormat format = DefaultFormat,
TextureFilter minFilter = DefaultMinFilter, TextureFilter magFilter = DefaultMagFilter,
TextureWrap wrapX = DefaultWrapX, TextureWrap wrapY = DefaultWrapY)
{
return(Graphics.CreateTexture2D(data,
width, height,
format,
minFilter, magFilter,
wrapX, wrapY));
}
internal OpenGLTexture(byte[] data, TextureType type,
int width, int height, int depth,
TextureFormat format,
TextureFilter minFilter, TextureFilter magFilter,
TextureWrap wrapX, TextureWrap?wrapY, TextureWrap?wrapZ)
{
Type = type;
Width = width;
Height = height;
Depth = depth;
Format = format;
id = GL.GenTexture();
switch (Type)
{
case TextureType.Texture1D when Platform.GraphicsBackend == GraphicsBackend.OpenGL: // Not available in OpenGL ES
TextureTarget = TextureTarget.Texture1D;
break;
case TextureType.Texture1DArray when Platform.GraphicsBackend == GraphicsBackend.OpenGL: // Not available in OpenGL ES
TextureTarget = TextureTarget.Texture1DArray;
break;
case TextureType.Texture2D:
TextureTarget = TextureTarget.Texture2D;
WrapY = wrapY.Value;
break;
case TextureType.Texture2DArray:
TextureTarget = TextureTarget.Texture2DArray;
WrapY = wrapY.Value;
break;
case TextureType.Texture2DMultisample:
TextureTarget = TextureTarget.Texture2DMultisample;
WrapY = wrapY.Value;
break;
case TextureType.Texture3D:
TextureTarget = TextureTarget.Texture3D;
WrapY = wrapY.Value;
WrapZ = wrapZ.Value;
break;
default:
throw new IllegalValueException(typeof(TextureType), Type);
}
MinFilter = minFilter;
MagFilter = magFilter;
WrapX = wrapX;
SetData(data);
}
protected TextureSampler(
TextureMinificationFilter minificationFilter,
TextureMagnificationFilter magnificationFilter,
TextureWrap wrapS,
TextureWrap wrapT,
float maximumAnistropy)
{
_minificationFilter = minificationFilter;
_magnificationFilter = magnificationFilter;
_wrapS = wrapS;
_wrapT = wrapT;
_maximumAnistropy = maximumAnistropy;
}
public DalamudCreditsWindow(Dalamud dalamud, TextureWrap logoTexture, Framework framework)
{
this.dalamud = dalamud;
this.logoTexture = logoTexture;
this.framework = framework;
framework.Gui.SetBgm(132);
var pluginCredits = dalamud.PluginManager.Plugins.Where(x => x.Definition != null).Aggregate(string.Empty, (current, plugin) => current + $"{plugin.Definition.Name} by {plugin.Definition.Author}\n");
this.creditsText =
string.Format(CreditsTextTempl, typeof(Dalamud).Assembly.GetName().Version, pluginCredits);
}
private int getWrapMode(TextureWrap wrap)
{
switch (wrap)
{
case TextureWrap.Clamp: return((int)TextureWrapMode.ClampToEdge);
case TextureWrap.MirroredRepeat: return((int)TextureWrapMode.MirroredRepeat);
case TextureWrap.Repeat: return((int)TextureWrapMode.Repeat);
default: throw new NotSupportedException(wrap.ToString());
}
}
public static TextureSampler CreateTexture2DSampler(
TextureMinificationFilter minificationFilter,
TextureMagnificationFilter magnificationFilter,
TextureWrap wrapS,
TextureWrap wrapT)
{
return(new TextureSamplerGL3x(
minificationFilter,
magnificationFilter,
wrapS,
wrapT,
1));
}
protected TextureSampler(
TextureMinificationFilter minificationFilter,
TextureMagnificationFilter magnificationFilter,
TextureWrap wrapS,
TextureWrap wrapT,
float maximumAnistropy)
{
_minificationFilter = minificationFilter;
_magnificationFilter = magnificationFilter;
_wrapS = wrapS;
_wrapT = wrapT;
_maximumAnistropy = maximumAnistropy;
}
private static TextureWrap LoadImage(string file)
{
if (TextureCache.ContainsKey(file))
{
return(TextureCache[file]);
}
TextureWrap tex = Plugin.PluginInterface.UiBuilder.LoadImage(file);
LoadedResources.Add(tex);
TextureCache.Add(file, tex);
return(tex);
}
public void unsafeSetWrap(TextureWrap u, TextureWrap v, bool force)
{
if (u != null && (force || uWrap != u))
{
GL.TexParameter(glTarget, TextureParameterName.TextureWrapS, TextureHelper.getGLEnumFromTextureWrap(u));
uWrap = u;
}
if (v != null && (force || vWrap != v))
{
GL.TexParameter(glTarget, TextureParameterName.TextureWrapT, TextureHelper.getGLEnumFromTextureWrap(v));
vWrap = v;
}
}
public static TextureSampler CreateTexture2DSampler(
TextureMinificationFilter minificationFilter,
TextureMagnificationFilter magnificationFilter,
TextureWrap wrapS,
TextureWrap wrapT,
float maximumAnistropy)
{
return(new TextureSamplerGL3x(
minificationFilter,
magnificationFilter,
wrapS,
wrapT,
maximumAnistropy));
}
/// <summary>
/// Initializes a new instance of the <see cref="CreditsWindow"/> class.
/// </summary>
/// <param name="dalamud">The Dalamud instance.</param>
public CreditsWindow(Dalamud dalamud)
: base("Dalamud Credits", ImGuiWindowFlags.NoCollapse | ImGuiWindowFlags.NoResize, true)
{
this.dalamud = dalamud;
this.logoTexture = this.dalamud.InterfaceManager.LoadImage(Path.Combine(this.dalamud.AssetDirectory.FullName, "UIRes", "logo.png"));
this.creditsThrottler = new();
this.Size = new Vector2(500, 400);
this.SizeCondition = ImGuiCond.Always;
this.PositionCondition = ImGuiCond.Always;
this.BgAlpha = 0.5f;
}
private STTextureWrapMode ConvertWrapMode(TextureWrap PicaWrapMode)
{
switch (PicaWrapMode)
{
case TextureWrap.Repeat: return(STTextureWrapMode.Repeat);
case TextureWrap.Mirror: return(STTextureWrapMode.Mirror);
case TextureWrap.ClampToBorder: return(STTextureWrapMode.Clamp);
case TextureWrap.ClampToEdge: return(STTextureWrapMode.Clamp);
default: return(STTextureWrapMode.Repeat);
}
}
private PICATextureWrap ConvertWrapMode(TextureWrap wrapMode)
{
switch (wrapMode)
{
case TextureWrap.ClampToBorder: return(PICATextureWrap.ClampToBorder);
case TextureWrap.ClampToEdge: return(PICATextureWrap.ClampToEdge);
case TextureWrap.Mirror: return(PICATextureWrap.Mirror);
case TextureWrap.Repeat: return(PICATextureWrap.Repeat);
default: return(PICATextureWrap.Repeat);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ChangelogWindow"/> class.
/// </summary>
public ChangelogWindow()
: base("What's new in XIVLauncher?", ImGuiWindowFlags.AlwaysAutoResize | ImGuiWindowFlags.NoResize)
{
this.Namespace = "DalamudChangelogWindow";
this.Size = new Vector2(885, 463);
this.SizeCondition = ImGuiCond.Appearing;
var interfaceManager = Service <InterfaceManager> .Get();
var dalamud = Service <Dalamud> .Get();
this.logoTexture =
interfaceManager.LoadImage(Path.Combine(dalamud.AssetDirectory.FullName, "UIRes", "logo.png")) !;
}
public TextureSamplerGL3x(
TextureMinificationFilter minificationFilter,
TextureMagnificationFilter magnificationFilter,
TextureWrap wrapS,
TextureWrap wrapT,
float maximumAnistropy)
: base(
minificationFilter,
magnificationFilter,
wrapS,
wrapT,
maximumAnistropy)
{
_name = new SamplerNameGL3x();
int glMinificationFilter = (int)TypeConverterGL3x.To(minificationFilter);
int glMagnificationFilter = (int)TypeConverterGL3x.To(magnificationFilter);
int glWrapS = (int)TypeConverterGL3x.To(wrapS);
int glWrapT = (int)TypeConverterGL3x.To(wrapT);
GL.SamplerParameterI(_name.Value, (ArbSamplerObjects)All.TextureMinFilter, ref glMinificationFilter);
GL.SamplerParameterI(_name.Value, (ArbSamplerObjects)All.TextureMagFilter, ref glMagnificationFilter);
GL.SamplerParameterI(_name.Value, (ArbSamplerObjects)All.TextureWrapS, ref glWrapS);
GL.SamplerParameterI(_name.Value, (ArbSamplerObjects)All.TextureWrapT, ref glWrapT);
if (Device.Extensions.AnisotropicFiltering)
{
GL.SamplerParameter(_name.Value, (ArbSamplerObjects)All.TextureMaxAnisotropyExt, maximumAnistropy);
}
else
{
if (maximumAnistropy != 1)
{
throw new InsufficientVideoCardException("Anisotropic filtering is not supported. The extension GL_EXT_texture_filter_anisotropic was not found.");
}
}
}
public static void TexWrapT(TextureTarget target, TextureWrap param)
{
int i = (int)param;
Private.TexParameteri(target, Private.TextureParameterName.WrapT, ref i);
}
private void initialize(TextReader reader, Object texture, int textureWidth, int textureHeight)
{
TextureWidth = textureWidth;
TextureHeight = textureHeight;
Texture = texture;
Regions = new List<AtlasRegion>();
float invTexWidth = 1f / textureWidth;
float invTexHeight = 1f / textureHeight;
String[] tuple = new String[4];
// Skip past first page name.
while (true) {
String line = reader.ReadLine();
if (line.Trim().Length != 0)
break;
}
Format = (Format)Enum.Parse(typeof(Format), readValue(reader), false);
readTuple(reader, tuple);
MinFilter = (TextureFilter)Enum.Parse(typeof(TextureFilter), tuple[0]);
MagFilter = (TextureFilter)Enum.Parse(typeof(TextureFilter), tuple[1]);
String direction = readValue(reader);
UWrap = TextureWrap.ClampToEdge;
VWrap = TextureWrap.ClampToEdge;
if (direction == "x")
UWrap = TextureWrap.Repeat;
else if (direction == "y")
VWrap = TextureWrap.Repeat;
else if (direction == "xy")
UWrap = VWrap = TextureWrap.Repeat;
while (true) {
String line = reader.ReadLine();
if (line == null || line.Trim().Length == 0) break;
AtlasRegion region = new AtlasRegion();
region.Atlas = this;
region.Name = line;
region.Rotate = Boolean.Parse(readValue(reader));
readTuple(reader, tuple);
int x = int.Parse(tuple[0]);
int y = int.Parse(tuple[1]);
readTuple(reader, tuple);
int width = int.Parse(tuple[0]);
int height = int.Parse(tuple[1]);
region.U = x * invTexWidth;
region.V = y * invTexHeight;
region.U2 = (x + width) * invTexWidth;
region.V2 = (y + height) * invTexHeight;
region.Width = Math.Abs(width);
region.Height = Math.Abs(height);
if (readTuple(reader, tuple) == 4) { // split is optional
region.Splits = new int[] {int.Parse(tuple[0]), int.Parse(tuple[1]),
int.Parse(tuple[2]), int.Parse(tuple[3])};
if (readTuple(reader, tuple) == 4) { // pad is optional, but only present with splits
region.Pads = new int[] {int.Parse(tuple[0]), int.Parse(tuple[1]),
int.Parse(tuple[2]), int.Parse(tuple[3])};
readTuple(reader, tuple);
}
}
region.OriginalWidth = int.Parse(tuple[0]);
region.OriginalHeight = int.Parse(tuple[1]);
readTuple(reader, tuple);
region.OffsetX = int.Parse(tuple[0]);
region.OffsetY = int.Parse(tuple[1]);
region.Index = int.Parse(readValue(reader));
Regions.Add(region);
}
while (true) {
String line = reader.ReadLine();
if (line == null)
break;
if (line.Trim().Length != 0) throw new Exception("An atlas with multiple images is not supported.");
}
}
public TextureSlot(Texture texture, int uvIndex, float blendFactor, TextureOperation operation, TextureWrap wrapS, TextureWrap wrapT) {
this.Texture = texture;
this.UVIndex = uvIndex;
this.BlendFactor = blendFactor;
this.Operation = operation;
this.WrapS = wrapS;
this.WrapT = wrapT;
}
public static TextureWrapMode To(TextureWrap wrap)
{
switch (wrap)
{
case TextureWrap.Clamp:
return TextureWrapMode.ClampToEdge;
case TextureWrap.Repeat:
return TextureWrapMode.Repeat;
case TextureWrap.MirroredRepeat:
return TextureWrapMode.MirroredRepeat;
}
throw new ArgumentException("wrap");
}
public TextureSettings () {
this.MagFilter = this.MinFilter = TextureFilter.Linear;
this.WrapS = this.WrapT = TextureWrap.Clamp;
}
