public void CosntructionRequestCantBeNull()
{
var offer = new MaterialType[] { MaterialType.Brick };
var player = new Mock<IPlayer>();
Assert.Throws<ArgumentNullException>(() => new Trade(offer, null, player.Object));
}
public void ConstructionOfferCantBeNull()
{
var request = new MaterialType[] { MaterialType.Brick };
var player = new Mock<IPlayer>();
Assert.Throws<ArgumentNullException>(() => new Trade(null, request, player.Object));
}
public void ConstructionPlayerCantBeNull()
{
var request = new MaterialType[] { MaterialType.Lumber };
var offer = new MaterialType[] { MaterialType.Wool };
Assert.Throws<ArgumentNullException>(() => new Trade(offer, request, null));
}
public static Material Create(string description, MaterialType type, HttpPostedFileBase file, BaseDbContext db)
{
if (!type.Match(file))
return null;
string uploadFileName = DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetExtension(file.FileName);
string absolutFileName;
switch (type)
{
case MaterialType.Identity:
absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Identity/" + uploadFileName;
break;
case MaterialType.Avatar:
absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Avatar/" + uploadFileName;
break;
default:
absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Administrator/" + uploadFileName;
break;
}
//执行上传
if (File.Exists(absolutFileName))
{
File.Delete(absolutFileName);
}
file.SaveAs(absolutFileName);
Material material = new Material(uploadFileName, description, type);
//添加Material记录
db.Materials.Add(material);
//保存更改
db.SaveChanges();
return db.Materials.Find(material.Id);
}
public void InitialTileShouldBeDesert(MaterialType type)
{
var tile = new Mock<ITile>();
tile.Setup(t => t.Rawmaterial).Returns(type);
Assert.Throws<ArgumentException>(() => new Robber(tile.Object));
}
public void FarmTest(MaterialType type)
{
var tile = new Tile(1, 2, 3, type);
IRawMaterial material = tile.Farm();
Assert.Equal(type, material.Type);
}
public Table(string model, MaterialType initialMaterial, decimal price, decimal height,
decimal initalLength, decimal initialWidth)
: base(model, initialMaterial, price, height)
{
this.Length = initalLength;
this.Width = initialWidth;
}
public Furniture(string model, MaterialType materialType, decimal price, decimal height)
{
this.Model = model;
this.Price = price;
this.material = materialType;
this.height = height;
}
public void ConstructionCantTradeSeaAndDessert(MaterialType[] request, MaterialType[] offer)
{
var player = new Mock<IPlayer>();
Assert.Throws<ArgumentException>(() => new Trade(offer, request, player.Object));
}
protected Furniture(string model, decimal price, decimal height, MaterialType material)
{
this.Model = model;
this.Price = price;
this.Height = height;
this.material = material;
}
public ETool()
{
_processSpd = 0.0f;
_swingType = SwingType.Dig;
_materialType = MaterialType.Wood;
_maxRange = 0;
}
protected Furniture(string model, MaterialType type, decimal price, decimal height)
{
this.Model = model;
this._type = type;
this.Price = price;
this.Height = height;
}
public Table(string model, MaterialType material, decimal price, decimal height, decimal length, decimal width)
: base(model, material, price, height)
{
this.width = width;
this.length = length;
this.Area = this.Length*this.Width;
}
public Furniture(string initialModel, MaterialType initialMaterialType, decimal initialPrice, decimal initialHeight)
{
this.Model = initialModel;
this.materialType = initialMaterialType;
this.Price = initialPrice;
this.Height = initialHeight;
}
public void AddChilds(MaterialCategoryObject materialCategory)
{
try
{
Revision blRev = new Revision();
MaterialType bl = new MaterialType();
materialCategory.Types = bl.GetByCategory(materialCategory);
materialCategory.Revisions = blRev.GetByMaterialCategory(materialCategory);
foreach (MaterialTypeObject materialType in materialCategory.Types)
{
materialType.SubTypes = new MaterialSubType().GetSubTypesByType(materialType);
materialType.Revisions = blRev.GetByMaterialType(materialType);
materialType.ChildsAdded = true;
foreach (MaterialSubTypeObject materialSubType in materialType.SubTypes)
{
materialSubType.Revisions = blRev.GetByMaterialSubType(materialSubType);
materialSubType.ChildsAdded = true;
}
}
materialCategory.ChildsAdded = true;
}
catch (Exception exception1)
{
Exception innerException = exception1;
throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
}
public Texture2D TextureFromVertices(Vertices vertices, MaterialType type, Color color, float materialScale)
{
// copy vertices
Vertices verts = new Vertices(vertices);
// scale to display units (i.e. pixels) for rendering to texture
Vector2 scale = ConvertUnits.ToDisplayUnits(Vector2.One);
verts.Scale(ref scale);
// translate the boundingbox center to the texture center
// because we use an orthographic projection for rendering later
AABB vertsBounds = verts.GetCollisionBox();
verts.Translate(-vertsBounds.Center);
List<Vertices> decomposedVerts;
if (!verts.IsConvex())
{
decomposedVerts = EarclipDecomposer.ConvexPartition(verts);
}
else
{
decomposedVerts = new List<Vertices>();
decomposedVerts.Add(verts);
}
List<VertexPositionColorTexture[]> verticesFill =
new List<VertexPositionColorTexture[]>(decomposedVerts.Count);
materialScale /= _materials[type].Width;
for (int i = 0; i < decomposedVerts.Count; ++i)
{
verticesFill.Add(new VertexPositionColorTexture[3 * (decomposedVerts[i].Count - 2)]);
for (int j = 0; j < decomposedVerts[i].Count - 2; ++j)
{
// fill vertices
verticesFill[i][3 * j].Position = new Vector3(decomposedVerts[i][0], 0f);
verticesFill[i][3 * j + 1].Position = new Vector3(decomposedVerts[i].NextVertex(j), 0f);
verticesFill[i][3 * j + 2].Position = new Vector3(decomposedVerts[i].NextVertex(j + 1), 0f);
verticesFill[i][3 * j].TextureCoordinate = decomposedVerts[i][0] * materialScale;
verticesFill[i][3 * j + 1].TextureCoordinate = decomposedVerts[i].NextVertex(j) * materialScale;
verticesFill[i][3 * j + 2].TextureCoordinate = decomposedVerts[i].NextVertex(j + 1) * materialScale;
verticesFill[i][3 * j].Color =
verticesFill[i][3 * j + 1].Color = verticesFill[i][3 * j + 2].Color = color;
}
}
// calculate outline
VertexPositionColor[] verticesOutline = new VertexPositionColor[2 * verts.Count];
for (int i = 0; i < verts.Count; ++i)
{
verticesOutline[2 * i].Position = new Vector3(verts[i], 0f);
verticesOutline[2 * i + 1].Position = new Vector3(verts.NextVertex(i), 0f);
verticesOutline[2 * i].Color = verticesOutline[2 * i + 1].Color = Color.Black;
}
Vector2 vertsSize = new Vector2(vertsBounds.UpperBound.X - vertsBounds.LowerBound.X,
vertsBounds.UpperBound.Y - vertsBounds.LowerBound.Y);
return RenderTexture((int)vertsSize.X, (int)vertsSize.Y,
_materials[type], verticesFill, verticesOutline);
}
public Tile(int x, int y, int number, MaterialType material)
{
X = x;
Y = y;
Number = number;
Rawmaterial = material;
}
protected Furniture(string model, MaterialType materialType, decimal price, decimal height)
{
this.Model = model;
this.Price = price;
this.Height = height;
this.Material = materialType.ToString();
}
public override List<IObject> GetNotCulledObjectsList(MaterialType? Filter, CullerComparer CullerComparer = CullerComparer.None, Vector3? CameraPosition = null)
{
switch (CullerComparer)
{
case CullerComparer.ComparerFrontToBack:
System.Diagnostics.Debug.Assert(CameraPosition.HasValue);
ComparerFrontToBack.CameraPosition = CameraPosition.Value;
forward.Sort(ComparerFrontToBack);
deferred.Sort(ComparerFrontToBack);
break;
case CullerComparer.ComparerBackToFront:
System.Diagnostics.Debug.Assert(CameraPosition.HasValue);
ComparerBackToFront.CameraPosition = CameraPosition.Value;
forward.Sort(ComparerBackToFront);
deferred.Sort(ComparerBackToFront);
break;
default:
break;
}
if (Filter == PloobsEngine.Material.MaterialType.DEFERRED)
return deferred.ToList();
else if (Filter == PloobsEngine.Material.MaterialType.FORWARD)
return forward.ToList();
else
{
List<IObject> objs = new List<IObject>();
objs.AddRange(deferred);
objs.AddRange(forward);
return objs;
}
}
public static void fillSchemesMap () {
schemesMaterials = new Dictionary<WorkbenchSchemeType, MaterialType[]>();
MaterialType[] materials = new MaterialType[2];
materials[0] = MaterialType.STEEL_BAR;
materials[1] = MaterialType.WOOD_STICK;
schemesMaterials.Add(WorkbenchSchemeType.IRON_DAGGER, materials);
materials = new MaterialType[3];
materials[0] = MaterialType.STEEL_BAR;
materials[1] = MaterialType.STEEL_BAR;
materials[2] = MaterialType.WOOD_STICK;
schemesMaterials.Add(WorkbenchSchemeType.IRON_SWORD, materials);
materials = new MaterialType[3];
materials[0] = MaterialType.STEEL_BAR;
materials[1] = MaterialType.WOOD_STICK;
materials[2] = MaterialType.WOOD_STICK;
schemesMaterials.Add(WorkbenchSchemeType.IRON_AXE, materials);
materials = new MaterialType[4];
materials[0] = MaterialType.STEEL_BAR;
materials[1] = MaterialType.STEEL_BAR;
materials[2] = MaterialType.STEEL_BAR;
materials[3] = MaterialType.STEEL_BAR;
schemesMaterials.Add(WorkbenchSchemeType.STEEL_ARMOR, materials);
}
private Material(string name, string description, MaterialType type)
{
Id = Guid.NewGuid();
Name = name;
Description = description;
Time = DateTime.Now;
Type = type;
}
public Chair(string model, MaterialType materialType, decimal price, decimal height, int numberOfLegs)
{
this.Model = model;
this.MaterialType = materialType;
this.Price = price;
this.Height = height;
this.NumberOfLegs = numberOfLegs;
}
public Furniture(string model, string material, decimal price, decimal height)
{
this.Model = model;
this.Material = material;
this.Price = price;
this.Height = height;
this.materialType = FurnitureFactory.GetMaterialType(material);
}
public void ExpectExceptionIfPlayerMoreThen7Resources()
{
var player = new Mock<IPlayer>();
player.Setup(p => p.Inventory).Returns(Enumerable.Range(0, 6).Select(i => new Mock<IRawMaterial>().Object));
var materials = new MaterialType[] { MaterialType.Grain, MaterialType.Lumber };
Assert.Throws<InvalidOperationException>(() => new DiscardResourcesCommand(player.Object, materials));
}
public void CantAddUnsourcedOrSea(MaterialType type)
{
var material = new Mock<IRawMaterial>();
material.Setup(m => m.Type).Returns(type);
var player = new Player("Henk");
Assert.Throws<ArgumentException>(() => player.AddResources(material.Object));
}
public bool GetMaterialWrap(MaterialType type)
{
if (type == MaterialType.Face)
{
return false;
}
return true;
}
public void ConstructionBothRequestAndOfferCantBeEmpty()
{
var request = new MaterialType[] { };
var offer = new MaterialType[] { };
var player = new Mock<IPlayer>();
Assert.Throws<ArgumentException>(() => new Trade(offer, request, player.Object));
}
public void CantOfferInvalidResource(MaterialType material)
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentException>(() => bank.BuyResource(MaterialType.Grain, material, player.Object));
}
public Table(string model, MaterialType materialType, decimal price, decimal height, decimal length, decimal width)
{
this.Model = model;
this.MaterialType = materialType;
this.Price = price;
this.Height = height;
this.Length = length;
this.Width = width;
}
private void setMaterialType (MaterialType type) {
this.type = type;
setDescription(type.getDescription());
switch (type) {
case MaterialType.STEEL_BAR: setSprite(steelBar); break;
case MaterialType.WOOD_STICK: setSprite(woodStick); break;
default: Debug.Log("Unknown Material Type"); break;
}
}
public MarkupStyleDash(Vector3 start, Vector3 end, Vector3 dir, float length, float width, Color color, MaterialType materialType = MaterialType.RectangleLines)
: this(start, end, dir.AbsoluteAngle(), length, width, color, materialType)
{
}
public MarkupStyleDash(Vector3 position, float angle, float length, float width, Color color, MaterialType materialType = MaterialType.RectangleLines)
{
Position = position;
Angle = angle;
Length = length;
Width = width;
Color = color;
MaterialType = materialType;
}
public Texture2D CircleTexture(float radius, MaterialType type, Color color, float materialScale, float pixelsPerMeter)
{
return(EllipseTexture(radius, radius, type, color, materialScale, pixelsPerMeter));
}
public static int GetInt(this MaterialType type)
{
return((int)type);
}
public async Task <bool> DeleteAsync(MaterialType type, int groupId)
{
return(await _repository.DeleteAsync(groupId, Q
.CachingRemove(CacheKey(type))
));
}
private BaseMaterialParser getParser(MaterialType type)
{
return(this.parsers[type]);
}
public Material(MaterialType materialType)
{
MaterialType = materialType;
}
/// <summary>
/// Configures shaders in the shader cache for a given material type
/// </summary>
/// <param name="type">Material type to setup shader for</param>
/// <param name="shader">Shader object to apply</param>
public virtual void SetShaderForMaterialType(MaterialType type, Shader shader)
{
_shaderCache.Add(type, shader);
}
public Material(string name, double density, double elastic, double poissonRatio, MaterialType type = MaterialType.Elastic) : base()
{
Name = name;
Density = density;
Elasticity = elastic;
PoissonRatio = poissonRatio;
Type = type;
}
public AddOrEditDryingMaterialForm(DryingMaterial dryingMaterial, INumericFormat numericFormat)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.inConstruction = true;
this.iNumericFormat = numericFormat;
// populate the moisture substance combobox
IEnumerator en = SubstanceCatalog.GetInstance().GetMoistureSubstanceList().GetEnumerator();
while (en.MoveNext())
{
Substance substance = (Substance)en.Current;
this.comboBoxMoistureSubstance.Items.Add(substance);
}
this.comboBoxMoistureSubstance.SelectedIndex = 0;
if (dryingMaterial == null)
{
// new
this.isNew = true;
this.Text = "New Drying Material";
this.dryingMaterialCache = new DryingMaterialCache(DryingMaterialCatalog.GetInstance());
this.textBoxName.Text = "New Drying Material";
// populate the material type combobox
this.comboBoxType.Items.Add(DryingMaterialsControl.STR_MAT_TYPE_GENERIC_MATERIAL);
this.comboBoxType.Items.Add(DryingMaterialsControl.STR_MAT_TYPE_GENERIC_FOOD);
// this.comboBoxType.Items.Add(DryingMaterialsControl.STR_MAT_TYPE_SPECIAL_FOOD);
this.comboBoxType.SelectedIndex = 0;
string matTypeStr = this.comboBoxType.SelectedItem as string;
MaterialType matTypeEnum = DryingMaterialsControl.GetDryingMaterialTypeAsEnum(matTypeStr);
this.dryingMaterialCache.SetMaterialType(matTypeEnum);
Substance subst = this.comboBoxMoistureSubstance.SelectedItem as Substance;
this.dryingMaterialCache.MoistureSubstance = subst;
}
else
{
// edit
this.isNew = false;
this.Text = "Edit Drying Material";
this.dryingMaterialCache = new DryingMaterialCache(dryingMaterial, DryingMaterialCatalog.GetInstance());
this.textBoxName.Text = this.dryingMaterialCache.Name;
// populate the material type combobox
this.comboBoxType.Items.Add(DryingMaterialsControl.GetDryingMaterialTypeAsString(this.dryingMaterialCache.MaterialType));
this.comboBoxType.SelectedIndex = 0;
this.comboBoxMoistureSubstance.SelectedItem = this.dryingMaterialCache.MoistureSubstance;
}
this.labelSpecificHeat.InitializeVariable(this.dryingMaterialCache.SpecificHeatOfAbsoluteDryMaterial);
this.textBoxSpecificHeat.InitializeVariable(numericFormat, this.dryingMaterialCache.SpecificHeatOfAbsoluteDryMaterial);
this.substancesControl.SubstancesToShow = SubstancesToShow.Material;
this.dmComponentsControl.SetMaterialComponents(this.dryingMaterialCache, numericFormat);
this.UpdateTheUI(this.dryingMaterialCache.MaterialType);
this.dryingMaterialCache.MaterialTypeChanged += new MaterialTypeChangedEventHandler(dryingMaterialCache_MaterialTypeChanged);
this.dryingMaterialCache.MoistureSubstanceChanged += new MoistureSubstanceChangedEventHandler(dryingMaterialCache_MoistureSubstanceChanged);
this.substancesControl.ListViewSubstances.SelectedIndexChanged += new EventHandler(ListViewSubstances_SelectedIndexChanged);
this.inConstruction = false;
}
public Material(MaterialType material)
: this(material, RenderQueue.Opaque)
{
}
private Material(string name, string url, MaterialType materialType)
{
Name = name;
Url = url;
MaterialType = materialType;
}
public Material(MaterialType material, ShadingTechnique shadingTechnique, RenderQueue renderQueue)
{
CreateShader(material, shadingTechnique, renderQueue);
}
public Chair(string model, MaterialType materialType, decimal price, decimal height, int numberOfLegs)
: base(model, materialType, price, height)
{
this.NumberOfLegs = numberOfLegs;
}
private string CacheKey(MaterialType type) => CacheUtils.GetListKey(TableName, type.GetValue());
public JsonResult GetMaterialTypeById(int id)
{
MaterialType materialType = materialTypeManager.GetMaterialTypeById(id);
return(Json(materialType, JsonRequestBehavior.AllowGet));
}
public async Task <bool> IsExistsAsync(MaterialType type, string groupName)
{
var groups = await GetAllAsync(type);
return(groups.Exists(x => StringUtils.EqualsIgnoreCase(groupName, x.GroupName)));
}
/// <summary>
/// 上传永久素材（图片（image）、语音（voice）、视频（video）和缩略图（thumb））
/// </summary>
/// <param name="file"></param>
/// <param name="title"></param>
/// <param name="introduction"></param>
/// <param name="materialType"></param>
/// <param name="timeOut"></param>
/// <returns></returns>
public UploadForeverMaterialApiResult UploadForeverMaterial(string file, string title, string introduction, MaterialType materialType, int timeOut = 40000)
{
var url = GetAccessApiUrl("add_material", ApiName, urlParams: new Dictionary <string, string>()
{
{ "type", materialType.ToString() }
});
var resultStr = RequestUtility.HttpPost(
url,
null,
null,
new Dictionary <string, string>
{
["media"] = file,
}, encoding: Encoding.UTF8);
var result = JsonConvert.DeserializeObject <UploadForeverMaterialApiResult>(resultStr);
if (result != null)
{
result.DetailResult = resultStr;
}
RefreshAccessTokenWhenTimeOut(result);
return(result);
}
public static string ToString(this MaterialType d)
{
return(reverseLookup[d]);
}
/// <summary>
/// Метод. Возвращает тип материала как тестовую строку
/// </summary>
public string GetMaterialTypeAsString(MaterialType materialType)
{
return(Home.GetMaterialAsStringStatic(materialType));
}
internal static ParticleSystem AddSparks(GameObject mainObj, WispSkinnedEffect skin, MaterialType matType, Int32 count, Single size, Single lifetime)
{
var burstOn = count > 0;
if (!sparkCounter.ContainsKey(mainObj))
{
sparkCounter[mainObj] = 0u;
}
var obj = new GameObject("Sparks" + sparkCounter[mainObj]++);
obj.transform.parent = mainObj.transform;
obj.transform.localPosition = Vector3.zero;
obj.transform.localScale = Vector3.one;
obj.transform.localRotation = Quaternion.identity;
var ps = obj.AddComponent <ParticleSystem>();
var psr = obj.AddOrGetComponent <ParticleSystemRenderer>();
if (matType != MaterialType.Constant)
{
skin.AddRenderer(psr, matType);
}
BasicSetup(ps);
ps.useAutoRandomSeed = true;
var psMain = ps.main;
psMain.duration = lifetime * 2f;
psMain.loop = false;
psMain.startDelay = 0f;
psMain.startLifetime = new ParticleSystem.MinMaxCurve(lifetime * 0.75f, lifetime * 1.25f);
psMain.startSpeed = new ParticleSystem.MinMaxCurve(1f, 3f);
psMain.startSize3D = false;
psMain.startSize = new ParticleSystem.MinMaxCurve(size * 0.75f, size * 1.25f);
psMain.startRotation3D = false;
psMain.startRotation = 0f;
psMain.flipRotation = 0f;
psMain.startColor = Color.white;
psMain.gravityModifier = 0f;
psMain.simulationSpace = ParticleSystemSimulationSpace.World;
psMain.useUnscaledTime = false;
psMain.scalingMode = ParticleSystemScalingMode.Hierarchy;
psMain.playOnAwake = true;
psMain.emitterVelocityMode = ParticleSystemEmitterVelocityMode.Transform;
psMain.maxParticles = Mathf.Abs(count) * 2;
psMain.stopAction = ParticleSystemStopAction.None;
psMain.cullingMode = ParticleSystemCullingMode.AlwaysSimulate;
psMain.ringBufferMode = ParticleSystemRingBufferMode.Disabled;
var psEmis = ps.emission;
psEmis.enabled = true;
if (burstOn)
{
psEmis.burstCount = 1;
psEmis.SetBurst(0, new ParticleSystem.Burst(0f, count));
psEmis.rateOverTime = 0f;
psEmis.rateOverDistance = 0f;
}
else
{
psEmis.burstCount = 0;
psEmis.rateOverTime = 50f;
psEmis.rateOverDistance = 0f;
psEmis.rateOverTimeMultiplier = 1f;
psEmis.rateOverDistanceMultiplier = 1f;
}
var psShape = ps.shape;
psShape.enabled = false;
psShape.arcMode = ParticleSystemShapeMultiModeValue.Random;
psShape.arcSpread = 0f;
psShape.texture = null;
psShape.position = Vector3.zero;
psShape.rotation = Vector3.zero;
psShape.scale = Vector3.one;
psShape.randomDirectionAmount = 0f;
psShape.randomPositionAmount = 0f;
psShape.sphericalDirectionAmount = 0f;
//psShape.
var psLimVOL = ps.limitVelocityOverLifetime;
psLimVOL.enabled = true;
psLimVOL.separateAxes = false;
psLimVOL.limit = 1f;
psLimVOL.dampen = 0.1f;
psLimVOL.drag = 0f;
psLimVOL.multiplyDragByParticleSize = true;
psLimVOL.multiplyDragByParticleVelocity = true;
var psCOL = ps.colorOverLifetime;
psCOL.enabled = true;
psCOL.color = new ParticleSystem.MinMaxGradient(new Gradient
{
mode = GradientMode.Blend,
alphaKeys = new[]
{
new GradientAlphaKey(1f, 0f),
new GradientAlphaKey(0f, 1f),
},
colorKeys = new[]
{
new GradientColorKey(Color.white, 0f),
new GradientColorKey(Color.white, 1f),
},
});
var psNoise = ps.noise;
psNoise.enabled = true;
psNoise.separateAxes = false;
psNoise.strength = 2f;
psNoise.frequency = 0.5f;
psNoise.scrollSpeed = 0f;
psNoise.damping = false;
psNoise.octaveCount = 1;
psNoise.octaveMultiplier = 0.5f;
psNoise.octaveScale = 2f;
psNoise.quality = ParticleSystemNoiseQuality.Medium;
psNoise.remapEnabled = false;
psNoise.positionAmount = 1f;
psNoise.rotationAmount = 0f;
psNoise.sizeAmount = 0f;
psr.renderMode = ParticleSystemRenderMode.Billboard;
psr.normalDirection = 1f;
psr.sortMode = ParticleSystemSortMode.None;
psr.minParticleSize = 0f;
psr.maxParticleSize = size;
psr.alignment = ParticleSystemRenderSpace.View;
psr.flip = Vector3.zero;
psr.allowRoll = true;
psr.pivot = Vector3.zero;
psr.maskInteraction = SpriteMaskInteraction.None;
//psr.SetActiveVertexStreams( null );
psr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
psr.receiveShadows = true;
psr.shadowBias = 0f;
psr.motionVectorGenerationMode = MotionVectorGenerationMode.Object;
psr.sortingLayerID = default;
psr.sortingOrder = 0;
psr.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.BlendProbes;
psr.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Simple;
psr.probeAnchor = null;
return(ps);
}
public Task <string> GetMaterialDataAsync(MaterialType materialType)
{
var path = GetMaterialPath(materialType);
return(Task.FromResult(File.ReadAllText(path)));
}
public MarkupStyleDash(Vector3 start, Vector3 end, float angle, float length, float width, Color color, MaterialType materialType = MaterialType.RectangleLines)
: this((start + end) / 2, angle, length, width, color, materialType)
{
}
public static string GetMaterialTypeDesc(MaterialType type)
{
return(MultiLanguage.Instance.GetTextValue(type.TypeDesc));
}
public MarkupStyleDash(Vector3 start, Vector3 end, Vector3 dir, float width, Color color, MaterialType materialType = MaterialType.RectangleLines)
: this(start, end, dir, (end - start).magnitude, width, color, materialType)
{
}
public static Sprite GetMaterialTypeSprite(MaterialType type)
{
return(Utility.LoadSprite(type.TypeIcon));
}
public MineralNode(MaterialType type, Area area, uint[] values) : this(type, area)
{
Debug.Assert(values.Length == area.Ground);
InitValus(values);
}
private void register(MaterialType type, BaseMaterialParser parse, string shaderAsset)
{
parse.Init(shaderAsset);
this.parsers.Add(type, parse);
}
private InvisibleMaterial(MaterialType MaterialType)
{
this.materialType = MaterialType;
}
public Material(MaterialType material, RenderQueue renderQueue)
: this(material, Graphics.GetCurrent(true).CurrentShadingTechnique, renderQueue)
{
}
