public ModelInvokeResult <SubSetPK> Update(string strSubSetId, SubSet subSet) { ModelInvokeResult <SubSetPK> result = new ModelInvokeResult <SubSetPK> { Success = true }; try { List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>(); string _SubSetId = strSubSetId; subSet.SubSetId = _SubSetId; /***********************begin 自定义代码*******************/ subSet.OperatedBy = NormalSession.UserId.ToGuid(); subSet.OperatedOn = DateTime.Now; //subSet.DataSource = GlobalManager.DIKey_00012_ManualEdit; /***********************end 自定义代码*********************/ statements.Add(new IBatisNetBatchStatement { StatementName = subSet.GetUpdateMethodName(), ParameterObject = subSet.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE }); /***********************begin 自定义代码*******************/ /***********************此处添加自定义代码*****************/ /***********************end 自定义代码*********************/ BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements); result.instance = new SubSetPK { SubSetId = _SubSetId }; } catch (Exception ex) { result.Success = false; result.ErrorMessage = ex.Message; } return(result); }
public void LoadBody(byte[] array) { BinaryReader br = new BinaryReader(new MemoryStream(array)); // matname = br.ReadPackString(); int lodcount = br.ReadInt32(); LODs = new List<Model>(); for (int i = 0; i < lodcount; i++) { SubSet[] LodSubset = new SubSet[br.ReadInt32()]; for (int j = 0; j < LodSubset.Length; j++) { string[] names = new string[br.ReadInt32()]; for (int n = 0; n < names.Length; n++) names[n] = br.ReadPackString(); LodSubset[j] = new SubSet(names); } LODs.Add(new Model(LodSubset)); } IsShadowCaster = br.ReadBoolean(); IsShadowReceiver = br.ReadBoolean(); NeedRotate = br.ReadBoolean(); isTransparent = br.ReadBoolean(); isSelfIllumination = br.ReadBoolean(); }
public bool CheckIfAllItemsAreCorrect() { SubSet correct = myLockObjects[0].correctSet; foreach (var item in myLockObjects) { if (item.gameObject.activeSelf == false) { return(false); } if (item.correctSet != correct) { return(false); } } if (correct.correctSet) { return(true); } else { return(false); } }
public void Initialize(SubSet set) { isLocked = false; mySection = GetComponentInParent <Section>(); mySet = GetComponentInParent <SubSet>(); myRenderer = GetComponent <Renderer>(); correctSet = set; }
/// <summary> /// Adds a new element to the list. /// </summary> /// <param name="subSet">SubSet to add.</param> /// <param name="state">State of <see cref="SubSet"/>.</param> public void Add(SubSet subSet, SceneState state) { RenderElement element = new RenderElement(subSet, new SceneState()); // todo reuse renderElements state.CopyTo(element.State); Add(element); }
private void SetSubSet(SubSet subSet, int i) { if (subSet.VertexUnit.Format.Contains(Semantic.BoneIndices)) { PositionStream posStream = (PositionStream)subSet.VertexUnit[typeof(PositionStream)]; boneIndicesStream[i] = (IBoneIndicesStream)subSet.VertexUnit[typeof(IBoneIndicesStream)]; boneWeightsStream[i] = (IBoneWeightsStream)subSet.VertexUnit[typeof(IBoneWeightsStream)]; source[i] = (Vector3[])posStream.Data.Clone(); subSets[i] = subSet; } }
/// <summary> /// Calculates a the ShadowVolume for a certain lightPosition. /// </summary> /// <param name="light">The light that is used for casting the ShadowVolume.</param> /// <param name="world">The object to world space matrix.</param> /// <param name="recalcFaceNormals">Recalculates the face normals. This is just necessary if the vertices /// of the mesh are manipulated by the CPU like for SoftwareSkinning.</param> /// <returns>The ShadowVolume in form of an Mesh.</returns> public Mesh Calculate(Light light, Matrix4 world, bool recalcFaceNormals) { // Init variables int j = 0; // Calculate the object space light vector this.world = world; Vector4 osLight = light.Vector4 * Matrix4.Invert(world); // calc the method to use if (method == StencilMethod.Automatic) { currentMethod = CalcMethod(light, world); } else { currentMethod = method; } SetTechnique(currentMethod); // for all subsets of the mesh add the silohuette for (int iSubSet = 0; iSubSet < mesh.SubSets.Count; iSubSet++) { SubSet subset = mesh.SubSets[iSubSet]; SubSet shadow = shadowVolume.SubSets[iSubSet]; // get indices and positions PositionStream positionStream = (PositionStream)subset.VertexUnit[typeof(PositionStream)]; // recalc face normals if (recalcFaceNormals) { faceNormals[iSubSet] = subset.CalcFaceNormals(); } shadow.IndexBufferStart = j; CalcVisibilityInfo(ref j, iSubSet, osLight); if (indexStream.ElementSize == 2) { AddShadowVolume16(ref j, iSubSet, light, positionStream.Size / 2); } else { AddShadowVolume32(ref j, iSubSet, light, positionStream.Size / 2); } shadow.PrimitiveCount = (j - shadow.IndexBufferStart) / 3; } indexStream.Upload(); return(shadowVolume); }
public async Task <List <SubSet> > AddSubSet(SubSet subSet) { SubSet newSubSet = new SubSet { SetId = subSet.SetId, SubSetName = subSet.SubSetName }; _context.SubSets.Add(newSubSet); _context.SaveChanges(); return(await _context.SubSets.Where(x => x.SetId == newSubSet.SetId).OrderBy(ss => ss.SubSetName).ToListAsync()); }
public void Add() { var super = new Set <int>(); var sub = new SubSet <int>(super); Assert.False(sub.Add(0)); Assert.False(sub.Contains(0)); super.Add(0); Assert.False(sub.Contains(0)); Assert.True(sub.Add(0)); Assert.True(sub.Contains(0)); }
static void Main() { // Input array Console.WriteLine("Enter an array of integer elements on a single line, separated by commas:"); string input = Console.ReadLine(); // Split the elements into an array string[] inputElements = input.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); // Fill an integer array from string array int[] array = new int[inputElements.Length]; for (int i = 0; i < inputElements.Length; i++) { array[i] = int.Parse(inputElements[i]); } int n = array.Length; Console.Write("Enter the sum S = "); int s = int.Parse(Console.ReadLine()); Console.Write("Enter Subset size K = "); int k = int.Parse(Console.ReadLine()); int PowerSetSize = 1 << n; // equiavalent to Math.Pow(2, n) var PowerSet = // each subset contains a set of array elements from PowerSetIndex in Enumerable.Range(0, PowerSetSize) // for each new PowerSet Subset select // Return Elements from ArrayIndex in Enumerable.Range(0, array.Count()) // From the input Array toSearch where (PowerSetIndex & (1 << ArrayIndex)) != 0 // If PowerSet Index and ArrayIndex select array[ArrayIndex]; // have a matching bit return that Element // Find Subsets with Matching Sum PowerSet = from SubSet in PowerSet // for each existing subset in PowerSet where SubSet.Sum() == s && SubSet.Count() == k select SubSet; // Return the matching subsets // output if (PowerSet.Count() > 0) //if PowerSet has at least 1 matching subset { Console.WriteLine("yes"); } else { Console.WriteLine("no"); } // For each subset, separated by NewLine join it's sub elements in a string //Console.Write(string.Join("\n", PowerSet.Select(subset => string.Join(" ", subset)))); //Console.WriteLine(); }
static void Main() { // input int arraySize = int.Parse(Console.ReadLine()); // get array int[] toSearch = new int[arraySize]; for (int i = 0; i < arraySize; i++) { toSearch[i] = int.Parse(Console.ReadLine()); } // get SUM int toFindSum = int.Parse(Console.ReadLine()); // get Subset size int toFindSubsetLen = int.Parse(Console.ReadLine()); int PowerSetSize = 1 << arraySize; // equiavalent to Math.Pow(2, arraySize) var PowerSet = // each subset contains a set of array elements from PowerSetIndex in Enumerable.Range(0, PowerSetSize) // for each new PowerSet Subset select // Return Elements from ArrayIndex in Enumerable.Range(0, toSearch.Count()) // From the input Array toSearch where (PowerSetIndex & (1 << ArrayIndex)) != 0 // If PowerSet Index and ArrayIndex select toSearch[ArrayIndex]; // have a matching bit return that Element // Find Subsets with Matching Sum PowerSet = from SubSet in PowerSet // for each existing subset in PowerSet where SubSet.Sum() == toFindSum && // return if sum == toFindSUM SubSet.Count() == toFindSubsetLen // AND Count == required Length select SubSet; // Return the matching subsets // if PowerSet has at least 1 matching subset if (PowerSet.Count() > 0) { Console.WriteLine("yes"); // Print YES } else { Console.WriteLine("no"); // If not Print NO } // TODO: DELETE Console.Write(string.Join("\n", PowerSet.Select( // For each subset, separated by NewLine subset => string.Join(" ", subset)))); // join it's sub elements in a string }
private void SetMeshEntity(MeshEntity meshEntity) { int subSetCount = meshEntity.Mesh.SubSets.Count; subSets = new SubSet[subSetCount]; boneIndicesStream = new IBoneIndicesStream[subSetCount]; boneWeightsStream = new IBoneWeightsStream[subSetCount]; source = new Vector3[subSetCount][]; for (int i = 0; i < subSetCount; i++) { SubSet subSet = meshEntity.Mesh.SubSets[i]; SetSubSet(subSet, i); } tags = new Matrix4[subSetCount]; meshEntity.Tags = tags; entity = meshEntity; }
public void Switch(LockCheck other) { mySet.ownsLockedObject = false; var tempParent = other.transform.parent; var tempSet = other.mySet; other.transform.parent = transform.parent; other.mySet = mySet; other.mySet.myObjects[sectionId] = other.GetComponent <VisibilityCheck>(); other.mySet.myLockObjects[sectionId] = other; transform.parent = tempParent; mySet = tempSet; mySet.myLockObjects[sectionId] = this; mySet.myObjects[sectionId] = GetComponent <VisibilityCheck>(); }
// EXECUTION FUNCTIONS private void Start() { progressionManager = FindObjectOfType <ProgressionManager>(); otherSections = FindObjectsOfType <Section>().Where(s => s != this).ToArray(); FindObjectOfType <Blink>().blinkEvent += OnBlink; foreach (var s in sets) { s.Initialize(); } Scramble(); currentSelectionInt = 2; currentlyActiveSet = sets[2]; currentlyActiveSet.Load(); }
public void Reset() { done = false; inPosition = false; Scramble(); currentlyActiveSet.Unload(); foreach (var s in sets) { s.Reset(); } currentSelectionInt = 0; currentlyActiveSet = sets[0]; currentlyActiveSet.Load(); }
public void SubsSetTestsResultsInSucess() { int[] nums = new int[] { 1, 2, 3 }; var expectedResult = new List <IList <int> >() { new List <int>(), new List <int>() { 1 }, new List <int>() { 2 }, new List <int>() { 3 }, new List <int>() { 1, 2 }, new List <int>() { 1, 3 }, new List <int>() { 2, 3 }, new List <int>() { 1, 2, 3 } }; var result = new SubSet().Subsets(nums); var areEqual = CollectionsAreEqual.AreEqualListOfLists <int>(result, (IList <IList <int> >)expectedResult); Assert.IsTrue(areEqual); }
public void Remove() { var super = new Set <int>(); var sub = new SubSet <int>(super); super.Add(0); sub.Add(0); Assert.True(super.Remove(0)); Assert.False(sub.Contains(0)); Assert.False(sub.Remove(0)); super.Add(3); super.Add(5); sub.Add(3); sub.Add(5); super.RemoveWhere(n => n < 4); Assert.False(sub.Contains(3)); Assert.True(sub.Contains(5)); }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Properties //--------------------------------------------------------------- //--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// Creates a sky box entity. /// </summary> /// <param name="size">Size of sky box.</param> /// <param name="format"><see cref="VertexFormat"/> to use for skybox.</param> public SkyBoxEntity(Vector3 size, VertexFormat format) { // create streams VertexUnit vertexUnit = new VertexUnit(format, 8); PositionStream position = (PositionStream)vertexUnit[typeof(PositionStream)]; //TextureStream texture = (TextureStream)vertexUnit[ typeof(TextureStream) ]; IndexStream index = new IndexStream16(24); // fill position data position[0] = new Vector3(-size.X, -size.Y, size.Z); position[1] = new Vector3(size.X, -size.Y, size.Z); position[2] = new Vector3(size.X, -size.Y, -size.Z); position[3] = new Vector3(-size.X, -size.Y, -size.Z); position[4] = new Vector3(-size.X, size.Y, size.Z); position[5] = new Vector3(size.X, size.Y, size.Z); position[6] = new Vector3(size.X, size.Y, -size.Z); position[7] = new Vector3(-size.X, size.Y, -size.Z); subSet = new SubSet(vertexUnit, index); }
public bool CheckIfAllItemsAreInPosition() { SubSet correct = myLockObjects[0].correctSet; foreach (var item in myLockObjects) { if (item.correctSet != correct) { return(false); } } if (correct.correctSet) { return(true); } else { return(false); } }
private void ChangeSet() { currentSelectionInt++; if (currentSelectionInt >= sets.Length) { currentSelectionInt = 0; } currentlyActiveSet = sets[currentSelectionInt]; for (int i = 0; i < sets.Length; i++) { if (i == currentSelectionInt) { sets[i].Load(lockedObject); } else { sets[i].Unload(); } } }
public InvokeResult NullifySelected(string strSubSetIds) { InvokeResult result = new InvokeResult { Success = true }; try { List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>(); string[] arrSubSetIds = strSubSetIds.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); if (arrSubSetIds.Length == 0) { result.Success = false; result.ErrorCode = 59996; return(result); } string statementName = new SubSet().GetUpdateMethodName(); foreach (string strSubSetId in arrSubSetIds) { SubSet subSet = new SubSet { SubSetId = strSubSetId, Status = 0 }; /***********************begin 自定义代码*******************/ subSet.OperatedBy = NormalSession.UserId.ToGuid(); subSet.OperatedOn = DateTime.Now; //subSet.DataSource = GlobalManager.DIKey_00012_ManualEdit; /***********************end 自定义代码*********************/ statements.Add(new IBatisNetBatchStatement { StatementName = statementName, ParameterObject = subSet.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE }); } BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements); } catch (Exception ex) { result.Success = false; result.ErrorMessage = ex.Message; } return(result); }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Methods //--------------------------------------------------------------- private void UpdateMetaInfo() { faceNormals = new Vector3[mesh.SubSets.Count][]; backface = new bool[mesh.SubSets.Count][]; edges = new Edge[mesh.SubSets.Count][]; this.shadowVolume = new Mesh(); int maxIndex = 0; for (int iSubSet = 0; iSubSet < mesh.SubSets.Count; iSubSet++) { maxIndex = System.Math.Min(mesh.SubSets[iSubSet].VertexUnit.Size, maxIndex); } indexStream = IndexStream.Create(1024 * 16, maxIndex); for (int iSubSet = 0; iSubSet < mesh.SubSets.Count; iSubSet++) { SubSet subSet = mesh.SubSets[iSubSet]; faceNormals[iSubSet] = subSet.CalcFaceNormals(); backface[iSubSet] = new bool[subSet.PrimitiveCount]; edges[iSubSet] = subSet.CalcEdges(); shadowVolume.SubSets.Add(new SubSet(subSet.VertexUnit, indexStream)); } }
public InvokeResult DeleteSelected(string strSubSetIds) { InvokeResult result = new InvokeResult { Success = true }; try { List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>(); string[] arrSubSetIds = strSubSetIds.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); if (arrSubSetIds.Length == 0) { result.Success = false; result.ErrorCode = 59996; return(result); } string statementName = new SubSet().GetDeleteMethodName(); foreach (string strSubSetId in arrSubSetIds) { SubSetPK pk = new SubSetPK { SubSetId = strSubSetId }; DeleteCascade(statements, pk); statements.Add(new IBatisNetBatchStatement { StatementName = statementName, ParameterObject = pk, Type = SqlExecuteType.DELETE }); } BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements); } catch (Exception ex) { result.Success = false; result.ErrorMessage = ex.Message; } return(result); }
/// <summary> /// Creates a new instance of <see cref="RenderElement"/>. /// </summary> /// <param name="subSet">The subSet to initialize element with.</param> /// <param name="state">The state to initialize element with.</param> public RenderElement(SubSet subSet, SceneState state) { this.subSet = subSet; this.state = state; }
public Model(SubSet[] array) { subsets = new List<SubSet>(array); }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// create an instance of a subSet entity /// </summary> /// <param name="subSet">subSet to render</param> public SubSetEntity(SubSet subSet) { this.subSet = subSet; }
public Model(SubSet[] array) { subsets = new SubSet[array.Length]; array.CopyTo(subsets, 0); }
/// <summary> /// Registers a <see cref="SubSet"/> for rendering. /// </summary> /// <param name="subSet"><see cref="SubSet"/> to add for rendering</param> public void RegisterForRendering(SubSet subSet) { renderList.Add(subSet, CurrentState); }