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);
}
