// Use this for initialization
protected virtual void Start()
{
_isConnected = false;
_videoPort = 7011;
_srcTexWrapper = new TextureWrapper();
RobotConnector.AddDependencyNode(this);
}
public override void Initialize()
{
TextureWrapper BackGround = new TextureWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.White, Vector2.Zero), @"Screens/WorldScreen/WorldScreenBackGround");
DisplayInfo = new TextWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.Black, new Vector2(510, 400)), @"Fonts/Normal", "");
AddtoList(BackGround);
AddtoList(DisplayInfo);
MapPoints[0] = new MapPoint(new Vector2(210, 390), "Brazil", 1);
MapPoints[1] = new MapPoint(new Vector2(100, 400), "Peru", 2);
MapPoints[2] = new MapPoint(new Vector2(70, 350), "Venzuela", 3);
MapPoints[3] = new MapPoint(new Vector2(380, 500), "Cameroon", 4);
MapPoints[4] = new MapPoint(new Vector2(460, 400), "Egypt", 5);
MapPoints[5] = new MapPoint(new Vector2(550, 300), "Yamen", 6);
MapPoints[6] = new MapPoint(new Vector2(630, 300), "India", 7);
MapPoints[7] = new MapPoint(new Vector2(720, 220), "Japan", 8);
MapPoints[8] = new MapPoint(new Vector2(500, 120), "Russia", 9);
MapPoints[9] = new MapPoint(new Vector2(440, 60), "North Pole", 10);
for (int i = 0; i < 10; i++)
{
AddtoList(new WorldButtons.SelectLevelButton(MapPoints[i].Level, MapPoints[i].Position, MapPoints[i].Name, (i < GameState.CurrentProfile.Level) ? true : false));
}
AddtoList(new WorldButtons.WorkShopButton(new Vector2(130, 100)));
AddtoList(new WorldButtons.BackButton());
base.Initialize();
}
public Texture2d LoadTexture(sd.Bitmap bitmap)
{
var sdbmp = (sd.Bitmap)bitmap.Clone();
TextureWrapper tw = new TextureWrapper();
tw.SDBitmap = sdbmp;
return(new Texture2d(this, tw, bitmap.Width, bitmap.Height));
}
public override void Initialize()
{
TextureWrapper BackGround = new TextureWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.White, Vector2.Zero), @"Screens/CreditsScreen/CreditsScreenBackGround");
AddtoList(BackGround);
AddtoList(new CreditsButtons.BackButton());
base.Initialize();
}
public Texture2d LoadTexture(BitmapBuffer bmp)
{
//definitely needed (by TextureFrugalizer at least)
var sdbmp = bmp.ToSysdrawingBitmap();
var tw = new TextureWrapper();
tw.SDBitmap = sdbmp;
return(new Texture2d(this, tw, bmp.Width, bmp.Height));
}
public RenderTarget CreateRenderTarget(int w, int h)
{
var tw = new TextureWrapper()
{
Texture = CreateRenderTargetTexture(w, h)
};
var tex = new Texture2d(this, tw, w, h);
var rt = new RenderTarget(this, tw, tex);
_renderTargets.Add(rt);
return(rt);
}
public RenderTarget CreateRenderTarget(int w, int h)
{
var d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
var tw = new TextureWrapper()
{
Texture = d3dtex
};
var tex = new Texture2d(this, tw, w, h);
RenderTarget rt = new RenderTarget(this, tw, tex);
return(rt);
}
public Texture2d LoadTexture(BitmapBuffer bmp)
{
var tex = new d3d9.Texture(dev, bmp.Width, bmp.Height, 1, d3d9.Usage.None, d3d9.Format.A8R8G8B8, d3d9.Pool.Managed);
var tw = new TextureWrapper()
{
Texture = tex
};
var ret = new Texture2d(this, tw, bmp.Width, bmp.Height);
LoadTextureData(ret, bmp);
return(ret);
}
public void LoadAllTextures()
{
string[] files = Directory.GetFiles("01.frontend/Textures", "*");
foreach (var filename in files)
{
string name = Path.GetFileNameWithoutExtension(filename);
TextureWrapper wrapper = new TextureWrapper();
wrapper.Texture = Texture2D.FromFile(device, filename);
wrapper.ShaderResourceView = new ShaderResourceView(device, wrapper.Texture);
textures.Add(name, wrapper);
}
}
public void LoadAllTextures()
{
string[] files = Directory.GetFiles("01.frontend/Textures", "*");
foreach (var filename in files)
{
string name = Path.GetFileNameWithoutExtension(filename);
TextureWrapper wrapper = new TextureWrapper();
wrapper.Texture = Texture2D.FromFile(device, filename);
wrapper.ShaderResourceView = new ShaderResourceView(device, wrapper.Texture);
textures.Add(name, wrapper);
}
}
public unsafe RenderTarget CreateRenderTarget(int w, int h)
{
TextureWrapper tw = new TextureWrapper();
tw.SDBitmap = new Bitmap(w, h, sdi.PixelFormat.Format32bppArgb);
var tex = new Texture2d(this, tw, w, h);
RenderTargetWrapper rtw = new RenderTargetWrapper(this);
var rt = new RenderTarget(this, rtw, tex);
rtw.Target = rt;
return(rt);
}
void Start()
{
//Init UnityWebCamera plugin
_instance = CreateTextureWrapper();
_BlitterProcessor = new OffscreenProcessor("UnityCam/Image/Blitter");
_wrapper = new TextureWrapper();
//Add Post Renderer invoker, it will handle the rest
gameObject.AddComponent <UnityCamPostRenderer> ();
}
// Use this for initialization
void Start()
{
mr = gameObject.GetComponent <MeshRenderer> ();
mr.material.color = Color.black;
_texWrapper = new TextureWrapper();
_sampledTexture = new Texture2D(1, 1, TextureFormat.RGB24, false);
_subTexture = new RenderTexture(32, 32, 16, RenderTextureFormat.Default);
_dbWriter.AddKey("latency");
_dbWriter.AddKey("Framerate");
_dbWriter.AddKey("Network");
_ConnectClient();
Reset();
}
public override void Initialize()
{
TextureWrapper BackGround = new TextureWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.White, Vector2.Zero), @"Screens/MainMenuScreen/MainMenuBackGround");
TextWrapper Profile = new TextWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.White, new Vector2(10, 600)), @"Fonts/Normal", "Current Profile: " + GameState.CurrentProfile.Name);
AddtoList(BackGround);
AddtoList(Profile);
AddtoList(new MainMenuButtons.PlayButton());
AddtoList(new MainMenuButtons.CreditsButton());
AddtoList(new MainMenuButtons.ChangeProfileButton());
AddtoList(new MainMenuButtons.ExitButton());
base.Initialize();
}
public void Read(FileReader reader, CTXB ctxb)
{
string Magic = reader.ReadSignature(4, "ctxb");
uint FileSize = reader.ReadUInt32();
uint ChunkCount = reader.ReadUInt32();
reader.ReadUInt32(); //padding
uint ChunkOffset = reader.ReadUInt32();
uint TextureDataOffset = reader.ReadUInt32();
for (int i = 0; i < ChunkCount; i++)
{
Chunks.Add(new Chunk(reader));
}
for (int i = 0; i < ChunkCount; i++)
{
for (int t = 0; t < Chunks[i].Textures.Count; t++)
{
var texWrapper = new TextureWrapper();
texWrapper.Text = $"Texture {t}";
texWrapper.ImageKey = "texture";
texWrapper.SelectedImageKey = texWrapper.ImageKey;
if (Chunks[i].Textures[t].Name != string.Empty)
{
texWrapper.Text = Chunks[i].Textures[t].Name;
}
texWrapper.Width = Chunks[i].Textures[t].Width;
texWrapper.Height = Chunks[i].Textures[t].Height;
texWrapper.Format = CTR_3DS.ConvertPICAToGenericFormat(Chunks[i].Textures[t].PicaFormat);
reader.SeekBegin(TextureDataOffset + Chunks[i].Textures[t].DataOffset);
texWrapper.ImageData = reader.ReadBytes((int)Chunks[i].Textures[t].ImageSize);
ctxb.Nodes.Add(texWrapper);
}
}
}
void Start()
{
//Init UnityWebCamera plugin
_instance = CreateTextureWrapper();
_BlitterProcessor = new OffscreenProcessor("UnityCam/Image/Blitter");
_wrapper = new TextureWrapper();
//If Camera already has a RenderTexture use this
Texture tex = GetComponent <Camera>().targetTexture;
if (tex is RenderTexture)
{
source = (RenderTexture)tex;
_deleteRenderTex = false;
}
else
{
source = new RenderTexture(WIDTH, HEIGHT, 24);
GetComponent <Camera>().targetTexture = source;
}
}
public RenderTarget CreateRenderTarget(int w, int h)
{
var d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
var tw = new TextureWrapper()
{
Texture = d3dtex
};
var tex = new Texture2d(this, tw, w, h);
RenderTarget rt = new RenderTarget(this, tw, tex);
ResetHandlers.Add(rt, "RenderTarget",
() =>
{
d3dtex.Dispose();
tw.Texture = null;
},
() =>
{
d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
tw.Texture = d3dtex;
}
);
return(rt);
}
public override void Initialize()
{
ProfileDescriptionString = "";
NewProfileString = "";
m_profileManager = new ProfileManager();
ProfileDescriptionWrapper = new TextWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.Black, new Vector2(65, 190)), @"Fonts/Normal", "");
NewProfileWrapper = new TextWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.Black, new Vector2(70, 450)), @"Fonts/Normal", "");
TextureWrapper BackGround = new TextureWrapper(new WrapperState(0, 1, 0, Vector2.Zero, Color.White, Vector2.Zero), @"Screens/ProfileScreen/ProfileBackGround");
AddtoList(BackGround);
AddtoList(ProfileDescriptionWrapper);
AddtoList(NewProfileWrapper);
AddtoList(new ProfileButtons.NextButton());
AddtoList(new ProfileButtons.PreviousButton());
AddtoList(new ProfileButtons.CreateNewButton());
AddtoList(new ProfileButtons.LoadButton());
AddtoList(new ProfileButtons.DeleteButton());
base.Initialize();
}
public RenderTarget CreateRenderTarget(int w, int h)
{
var d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
var tw = new TextureWrapper() { Texture = d3dtex };
var tex = new Texture2d(this, tw, w, h);
RenderTarget rt = new RenderTarget(this, tw, tex);
ResetHandlers.Add(rt, "RenderTarget",
() =>
{
d3dtex.Dispose();
tw.Texture = null;
},
() =>
{
d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
tw.Texture = d3dtex;
}
);
return rt;
}
private void DrawMap()
{
Puts("Drawing map...");
var width = _config.RenderResolution.Width;
var height = _config.RenderResolution.Height;
var coordinateConverter = new CoordinateConverter(width, height);
var raycastCoordinateConverter = new RaycastCoordinateConverter(coordinateConverter);
var layers = new List <ILayer>();
Puts("Initializing background layer...");
var backgroundTextureProvider =
new SeamlessProvider(new BitmapProvider(_config.BackgroundTexturePath.FullPath), width, height);
var backgroundLayer = new BitmapLayer(backgroundTextureProvider, NormalColorBlending.Instance);
layers.Add(backgroundLayer);
Puts("Initializing splat layers...");
foreach (var splatConfiguration in _config.SplatConfigurations)
{
Puts($"Splat #{splatConfiguration.Index}...");
var splatTextureProvider =
new SeamlessProvider(new BitmapProvider(splatConfiguration.TexturePath.FullPath), width, height);
var splatMask = new SplatMask(coordinateConverter, splatConfiguration.Index);
var splatLayer = new MaskedBitmapLayer(splatTextureProvider, splatMask, NormalColorBlending.Instance);
layers.Add(splatLayer);
}
Puts("Initializing materials source...");
var materialSource =
new DetailsLayer.MaterialSource(_config.DetailsConfiguration.MaterialConfigurations, width, height);
Puts("Initializing details layer...");
var detailsLayer = new DetailsLayer(raycastCoordinateConverter, materialSource,
_config.DetailsConfiguration.RaycastLayers);
layers.Add(detailsLayer);
Puts("Initializing light layer...");
var lightningLayer = new LightLayer(raycastCoordinateConverter, _config.LightConfiguration,
_config.LightConfiguration.RaycastLayers);
layers.Add(lightningLayer);
Puts("Initializing water layer...");
var waterTextureProvider =
new SeamlessProvider(new BitmapProvider(_config.WaterConfiguration.TexturePath.FullPath), height, width);
var waterMask = new WaterMask(raycastCoordinateConverter, _config.WaterConfiguration.MinOpacity,
_config.WaterConfiguration.MaxDepth, _config.WaterConfiguration.RaycastLayers);
var waterLayer = new MaskedBitmapLayer(waterTextureProvider, waterMask, NormalColorBlending.Instance);
layers.Add(waterLayer);
Puts("Initializing layer group...");
var layerGroup = new LayerGroup(layers);
var result = new Texture2D(width, height);
var wrapper = new TextureWrapper(result);
Puts("Drawing...");
layerGroup.Draw(wrapper);
Puts("Resizing to result resolution...");
TextureScale.Scale(result, _config.ResultResolution.Width, _config.ResultResolution.Height);
Puts("Saving result...");
Directory.CreateDirectory(_config.ResultPath.FullPath);
result.SaveAsPng(PathToResult);
wrapper.Dispose();
Puts("Done.");
}
private static void convertMaterials(MeshRenderer ren, Model mdl, GameObject tgt)
{
ModelModifiers model_trick = mdl.trck_node;
GeometryModifiersData geom_trick = mdl.src_mod;
RuntimeData rd = RuntimeData.get();
MaterialDescriptor descriptor;
string model_base_name = mdl.name.Split(new[] { "__" }, StringSplitOptions.None)[0];
string mesh_path = mdl.geoset.full_geo_path;
int obj_lib_idx = mesh_path.IndexOf("object_library");
if (obj_lib_idx != -1)
{
mesh_path = "Assets/Materials/" + mesh_path.Substring(obj_lib_idx);
}
string material_base_path = mesh_path + "/" + Path.GetFileNameWithoutExtension(mdl.name);
if (mdl.name == "Crate1_med_Wood__TintCrates")
{
Debug.LogFormat("Crate {0}", mdl.BlendMode.ToString());
}
if (model_trick != null && model_trick._TrickFlags.HasFlag(TrickFlags.ColorOnly))
{
// result = result.Clone(result.GetName()+"Colored");
// result.SetShaderParameter("MatDiffColor",Vector4(1.0, 1.0, 0.2f, 1.0f));
}
// Select material based on the model blend state
// Modify material based on the applied model tricks
Color onlyColor;
Color tint1 = new Color(1, 1, 1, 1); // Shader Constant 0
Color tint2 = new Color(1, 1, 1, 1); // Shader Constant 1
float alphaRef = 0.0f;
descriptor.depthWrite = true;
descriptor.isAdditive = false;
descriptor.targetCulling = UnityEngine.Rendering.CullMode.Back;
descriptor.depthTest = CompareFunction.LessEqual;
descriptor.targetCulling = UnityEngine.Rendering.CullMode.Back;
string shader_to_use = "";
if (null != model_trick && model_trick._TrickFlags != 0)
{
var tflags = model_trick._TrickFlags;
if (tflags.HasFlag(TrickFlags.Additive))
{
descriptor.isAdditive = true;
}
if (tflags.HasFlag(TrickFlags.ColorOnly))
{
onlyColor = model_trick.TintColor0;
}
if (tflags.HasFlag(TrickFlags.DoubleSided))
{
descriptor.targetCulling = UnityEngine.Rendering.CullMode.Off;
}
if (tflags.HasFlag(TrickFlags.NoZTest))
{
// simulate disabled Z test
descriptor.depthTest = CompareFunction.Always;
//depthTest = CompareFunction.Always;
descriptor.depthWrite = false;
}
if (tflags.HasFlag(TrickFlags.NoZWrite))
{
descriptor.depthWrite = false;
}
if (tflags.HasFlag(TrickFlags.SetColor))
{
tint1 = model_trick.TintColor0;
tint2 = model_trick.TintColor1;
tint1.a = 1.0f;
tint2.a = 1.0f;
}
if (tflags.HasFlag(TrickFlags.ReflectTex0) || tflags.HasFlag(TrickFlags.ReflectTex1))
{
shader_to_use = "Custom/ReflectGen";
if (mdl.flags.HasFlag(ModelFlags.OBJ_CUBEMAP))
{
Debug.Log("Unhandled Cubemap");
}
}
if (tflags.HasFlag(TrickFlags.AlphaRef))
{
//qDebug() << "Unhandled alpha ref";
alphaRef = geom_trick.AlphaRef;
}
if (tflags.HasFlag(TrickFlags.TexBias))
{
Debug.Log("Unhandled TexBias");
}
}
CompareFunction depthTest = CompareFunction.LessEqual;
TextureWrapper whitetex = GeoSet.loadTexHeader("white");
var pixel_defines = new List <string>();
pixel_defines.Add("DIFFMAP");
pixel_defines.Add("ALPHAMASK");
switch (mdl.BlendMode)
{
case CoHBlendMode.MULTIPLY:
pixel_defines.Add("COH_MULTIPLY");
break;
case CoHBlendMode.MULTIPLY_REG:
if (!descriptor.depthWrite && descriptor.isAdditive)
{
descriptor.targetCulling = UnityEngine.Rendering.CullMode.Off;
}
pixel_defines.Add("COH_MULTIPLY");
break;
case CoHBlendMode.COLORBLEND_DUAL:
pixel_defines.Add("COH_COLOR_BLEND_DUAL");
break;
case CoHBlendMode.ADDGLOW:
pixel_defines.Add("COH_ADDGLOW");
break;
case CoHBlendMode.ALPHADETAIL:
pixel_defines.Add("COH_ALPHADETAIL");
break;
case CoHBlendMode.BUMPMAP_MULTIPLY:
pixel_defines.Add("COH_MULTIPLY");
break;
case CoHBlendMode.BUMPMAP_COLORBLEND_DUAL:
pixel_defines.Add("COH_COLOR_BLEND_DUAL");
break;
}
if (mdl.flags.HasFlag(ModelFlags.OBJ_TREE))
{
shader_to_use = "CoH/Vegetation";
alphaRef = 0.4f;
tint1.a = 254.0f / 255.0f;
}
Material[] materials = new Material[mdl.texture_bind_info.Count];
int idx = 0;
Tools.EnsureDirectoryExists(material_base_path);
var sup = tgt.GetComponent <ModelNodeMods>();
sup.GeomTricks = geom_trick;
VBOPointers vbo = mdl.vbo;
Shader selected = null;
if (descriptor.isAdditive)
{
if (shader_to_use == "Custom/ReflectGen")
{
selected = Shader.Find("Custom/ReflectGen");
}
else
{
selected = Shader.Find("Unlit/Additive");
}
}
else
{
if (!String.IsNullOrEmpty(shader_to_use))
{
selected = Shader.Find(shader_to_use);
}
else
{
selected = Shader.Find("CoH/CoHMult");
}
}
sup.TexWrappers = vbo.assigned_textures;
foreach (TextureWrapper wrap in vbo.assigned_textures)
{
string path_material_name = String.Format("{0}/{1}_{2}.mat", material_base_path, idx, descriptor.GetHashCode());
Material available = AssetDatabase.LoadAssetAtPath <Material>(path_material_name);
if (available == null)
{
if (wrap != null)
{
TextureWrapper detail = null;
if (!String.IsNullOrEmpty(wrap.detailname))
{
detail = GeoSet.loadTexHeader(wrap.detailname);
}
Material mat = new Material(selected);
mat.enableInstancing = true;
mat.SetColor("_Color", tint1);
mat.SetColor("_Color2", tint2);
mat.SetFloat("_AlphaRef", alphaRef);
mat.SetInt("_CoHMod", (int)mdl.BlendMode);
mat.SetTexture("_MainTex", wrap.tex);
if (detail != null)
{
mat.SetTexture("_Detail", detail.tex);
}
mat.SetInt("_ZWrite", descriptor.depthWrite ? 1 : 0);
mat.SetInt(ZTest, (int)descriptor.depthTest);
mat.SetInt(CullMode, (int)descriptor.targetCulling);
mat.SetTextureScale(MainTex, wrap.scaleUV1);
mat.SetTextureScale(Detail, wrap.scaleUV0);
AssetDatabase.CreateAsset(mat, path_material_name);
AssetDatabase.SaveAssets();
available = AssetDatabase.LoadAssetAtPath <Material>(path_material_name);
}
}
materials[idx++] = available;
}
if (mdl.flags.HasFlag(ModelFlags.OBJ_HIDE))
{
ren.enabled = false;
}
ren.sharedMaterials = materials;
}
public void Load(System.IO.Stream stream)
{
Text = FileName;
using (var reader = new FileReader(stream, true))
{
reader.SetByteOrder(false);
uint numTextures = reader.ReadUInt32();
for (int i = 0; i < numTextures; i++)
{
uint offset = reader.ReadUInt32();
uint size = reader.ReadUInt32();
if (size == 0)
{
continue;
}
using (reader.TemporarySeek(offset, System.IO.SeekOrigin.Begin))
{
TextureWrapper entry = new TextureWrapper();
entry.ImageKey = "texture";
entry.SelectedImageKey = "texture";
entry.Format = TEX_FORMAT.R8G8B8A8_UNORM;
entry.Text = reader.ReadZeroTerminatedString();
reader.SeekBegin(offset + 48);
ulong unk = reader.ReadUInt64(); //Varies. Shifts like a offset or size
ulong headerOffset = reader.ReadUInt64();
ulong sectionSize = reader.ReadUInt64();
ulong unk3 = reader.ReadUInt64(); //16
ulong unk4 = reader.ReadUInt64(); //4
reader.SeekBegin(offset + 48 + headerOffset);
reader.ReadUInt32(); //padding
uint unk5 = reader.ReadUInt32(); //C03F
ulong unk6 = reader.ReadUInt64(); //32
if (unk6 != 32)
{
//Platform PC
reader.Seek(-8);
uint unk7 = reader.ReadUInt32();
uint unk8 = reader.ReadUInt32();
uint unk9 = reader.ReadUInt32();
uint unk10 = reader.ReadUInt32();
entry.Width = reader.ReadUInt32();
entry.Height = reader.ReadUInt32();
entry.Depth = reader.ReadUInt32();
entry.ArrayCount = reader.ReadUInt32();
reader.Seek(44);
uint imageSize = reader.ReadUInt32();
reader.Seek(16);
entry.Parameters.DontSwapRG = true;
entry.ImageData = reader.ReadBytes((int)imageSize);
}
else
{
entry.PlatformSwizzle = PlatformSwizzle.Platform_Switch;
//Platform switch
ulong unk7 = reader.ReadUInt64(); //24
ulong unk8 = reader.ReadUInt64(); //40
//Matches XTX info header
uint imageSize = reader.ReadUInt32();
uint Alignment = reader.ReadUInt32();
entry.Width = reader.ReadUInt32();
entry.Height = reader.ReadUInt32();
entry.Depth = reader.ReadUInt32();
entry.Target = reader.ReadUInt32();
uint Format = reader.ReadUInt32();
uint unk10 = reader.ReadUInt32(); //1
entry.ImageData = reader.ReadBytes((int)imageSize);
entry.Format = XTX.TextureInfo.ConvertFormat(Format);
}
Nodes.Add(entry);
}
}
}
}
public RenderTarget CreateRenderTarget(int w, int h)
{
var d3dtex = new d3d9.Texture(dev, w, h, 1, d3d9.Usage.RenderTarget, d3d9.Format.A8R8G8B8, d3d9.Pool.Default);
var tw = new TextureWrapper() { Texture = d3dtex };
var tex = new Texture2d(this, tw, w, h);
RenderTarget rt = new RenderTarget(this, tw, tex);
return rt;
}
public Texture2d LoadTexture(BitmapBuffer bmp)
{
var tex = new d3d9.Texture(dev, bmp.Width, bmp.Height, 1, d3d9.Usage.None, d3d9.Format.A8R8G8B8, d3d9.Pool.Managed);
var tw = new TextureWrapper() { Texture = tex };
var ret = new Texture2d(this, tw, bmp.Width, bmp.Height);
LoadTextureData(ret, bmp);
return ret;
}
/// <summary>
/// Constructs a new loading bar.
/// </summary>
/// <param name="State">State of the images.</param>
/// <param name="BackGroundPath">Background image path.</param>
/// <param name="CoverPath">Cover image path.</param>
public LoadingBar(WrapperState State, string BackGroundPath, string CoverPath)
{
BackGround = new TextureWrapper(State, BackGroundPath);
Cover = new TextureWrapper(State, CoverPath);
}
