public void StoreQuestion(Question question)
{
using (var redis = RedisManager.GetClient())
{
var redisQuestions = redis.As <Question>();
if (question.Tags == null)
{
question.Tags = new List <string>();
}
if (question.Id == default(long))
{
question.Id = redisQuestions.GetNextSequence();
question.CreatedDate = DateTime.UtcNow;
//Increment the popularity for each new question tag
question.Tags.ForEach(tag => redis.IncrementItemInSortedSet(TagIndex.All, tag, 1));
}
redisQuestions.Store(question);
redisQuestions.AddToRecentsList(question);
redis.AddItemToSet(UserQuestionIndex.Questions(question.UserId), question.Id.ToString());
//Populate tag => questions index for each tag
question.Tags.ForEach(tag => redis.AddItemToSet(TagIndex.Questions(tag), question.Id.ToString()));
}
}
/// <summary>
/// Delete question by performing compensating actions to StoreQuestion() to keep the datastore in a consistent state
/// </summary>
/// <param name="questionId"></param>
public void DeleteQuestion(long questionId)
{
using (var redis = RedisManager.GetClient())
{
var redisQuestions = redis.As <Question>();
var question = redisQuestions.GetById(questionId);
if (question == null)
{
return;
}
//decrement score in tags list
question.Tags.ForEach(tag => redis.IncrementItemInSortedSet(TagIndex.All, tag, -1));
//remove all related answers
redisQuestions.DeleteRelatedEntities <Answer>(questionId);
//remove this question from user index
redis.RemoveItemFromSet(UserQuestionIndex.Questions(question.UserId), questionId.ToString());
//remove tag => questions index for each tag
question.Tags.ForEach(tag => redis.RemoveItemFromSet(TagIndex.Questions(tag), questionId.ToString()));
redisQuestions.DeleteById(questionId);
}
}
internal void LoadTagDatums(TagIndex tagIndex)
{
var classes = tagIndex.ClassHeirarchies.Select(x => x.Class);
treeView1.SuspendLayout( );
foreach (var tagClass in classes)
{
var tags = tagIndex.Where(tagClass).ToArray( );
if (tags.Length <= 0)
{
continue;
}
var node = new TreeNode(tagClass.ToString( ));
var childrenNodes = new TreeNode[tags.Length];
for (var index = 0; index < tags.Length; index++)
{
var tagDatum = tags[index];
childrenNodes[index] = new TreeNode(tagDatum.Path)
{
Tag = tagDatum
};
}
node.Nodes.AddRange(childrenNodes);
treeView1.Nodes.Add(node);
}
treeView1.ResumeLayout( );
}
/// <summary>
/// Halo1 export interface class constructor
/// </summary>
/// <param name="tag_index">Tag index containing the tag being exported</param>
/// <param name="tag_datum">DatumIndex of the tag being exported</param>
public ColladaHalo1(TagIndex tag_index, DatumIndex tag_datum)
{
tagIndex = tag_index;
tagManager = tag_index[tag_datum];
GenerateInfoList();
}
///-------------------------------------------------------------------------------------------------
/// <summary> Creates the node list. </summary>
///-------------------------------------------------------------------------------------------------
private void CreateNodeList()
{
// Get all of the object instances to include
var objectInstances = mScenarioDataProvider.GetObjectInstances();
for (int i = 0; i < objectInstances.Count; i++)
{
var objectInstance = objectInstances[i];
// Create a node for the object instance
ColladaNCName nodeName = "";
if (objectInstance.ObjectName == null)
{
if (!TagIndex.IsValid(objectInstance.ObjectType.ObjectTagDatum))
{
throw new ColladaException("Failed to load the object type tag {0}", objectInstance.ObjectType.ObjectTagPath);
}
ColladaNCName objectName = Path.GetFileNameWithoutExtension(mTagIndex[objectInstance.ObjectType.ObjectTagDatum].Name);
nodeName = i.ToString() + "-" + objectName;
}
else
{
nodeName = objectInstance.ObjectName.Name;
}
var node = CreateNode(nodeName, "", "", Enums.ColladaNodeType.NODE);
// Set the nodes position
var translate = new Core.ColladaTranslate();
translate.SetTranslate(objectInstance.Position, 100);
node.Add(translate);
// Set the nodes rotation
node.AddRange(
ColladaUtilities.CreateRotationSet(objectInstance.Rotation.R, objectInstance.Rotation.P, objectInstance.Rotation.Y
, new LowLevel.Math.real_vector3d(1, 0, 0)
, new LowLevel.Math.real_vector3d(0, -1, 0)
, new LowLevel.Math.real_vector3d(0, 0, 1)
, ColladaUtilities.ColladaRotationOrder.XYZ)
);
var nodeIdList = GetNodeReferences(objectInstance.ObjectType, objectInstance.Permutation.ToString("D2"));
if (nodeIdList.Count > 0)
{
node.InstanceNode = new List <ColladaInstanceNode>();
foreach (var nodeId in nodeIdList)
{
node.InstanceNode.Add(new ColladaInstanceNode()
{
URL = "#" + nodeId
});
}
}
listNode.Add(node);
}
}
public List <QuestionResult> GetQuestionsTaggedWith(string tagName)
{
using var redis = RedisManager.GetReadOnlyClient();
var questionIds = redis.GetAllItemsFromSet(TagIndex.Questions(tagName));
var questions = redis.As <Question>().GetByIds(questionIds);
return(ToQuestionResults(questions));
}
public TagsController(EventStoreService eventStore, CacheDatabaseManager db, InMemoryCache cache)
{
_eventStore = eventStore;
_db = db;
_entityIndex = cache.Index <EntityIndex>();
_mediaIndex = cache.Index <MediaIndex>();
_tagIndex = cache.Index <TagIndex>();
_referencesIndex = cache.Index <ReferencesIndex>();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting
/// unmanaged resources.
/// </summary>
public void Dispose()
{
if (TagIndex.IsValid(mIndexHandle))
{
BlamLib.Program.GetManager(mGameVersion).CloseTagIndex(mIndexHandle);
mIndexInterface = null;
mIndexHandle = DatumIndex.Null;
}
}
private Module(string fileName, Module parentModule)
{
FileName = fileName;
using (var reader = CreateReader())
{
Header = reader.ReadObject <ModuleHeader>();
Items = new List <ModuleItem>(Header.ItemCount);
for (int i = 0; i < Header.ItemCount; i++)
{
Items.Add(reader.ReadObject <ModuleItem>((int)Header.Version));
}
var origin = reader.BaseStream.Position;
Strings = new Dictionary <int, string>();
while (reader.BaseStream.Position < origin + Header.StringsSize)
{
Strings.Add((int)(reader.BaseStream.Position - origin), reader.ReadNullTerminatedString());
}
Resources = new List <int>(Header.ResourceCount);
for (int i = 0; i < Header.ResourceCount; i++)
{
Resources.Add(reader.ReadInt32());
}
Blocks = new List <Block>(Header.BlockCount);
for (int i = 0; i < Header.BlockCount; i++)
{
Blocks.Add(reader.ReadObject <Block>((int)Header.Version));
}
DataAddress = reader.BaseStream.Position;
tagIndex = parentModule?.tagIndex ?? new TagIndex(Items);
linkedModules = parentModule?.linkedModules ?? new List <Module>(Enumerable.Repeat(this, 1));
}
}
private void LuceneInitIndex(Dictionary <TagNodeKey, List <TagNode> > tags)
{
if (bool.Parse(AppSettingCache.Instance["TagSearchAct"]))
{
Thread thread = new Thread(state =>
{
if (!_indexlock.TryEnter())
{
return;
}
try
{
_log.Info("TagCache开始建立LuceneNet索引");
var dic = TagLuceneNet.Instance.Init();
foreach (var kv in tags)
{
foreach (var tag in kv.Value)
{
TagIndex.AddTag(tag, kv.Key.Dimension, dic);
}
}
TagLuceneNet.Instance.CompleteIndex(dic);
_log.Info("TagCache索引建立完成");
}
catch (Exception ex)
{
_log.Error(ex);
}
finally
{
_indexlock.Exit();
}
});
thread.Start();
}
}
/// <summary>
/// Retrieves a reference to a tag stored in the runtime asset.
/// </summary>
/// <param name="tagIndex">The tag index to retrieve the reference for.</param>
/// <returns>Tag reference that corresponds to the index passed as argument.</returns>
public ref Tag GetTag(TagIndex tagIndex)
{
Assert.IsTrue(tagIndex < numTags);
return(ref tags[tagIndex]);
}
/// <summary>
/// Determines whether two tag indices are equal.
/// </summary>
/// <param name="tagIndex">The index to compare against the current index.</param>
/// <returns>True if the specified index is equal to the current index; otherwise, false.</returns>
public bool Equals(TagIndex tagIndex)
{
return(value == tagIndex.value);
}
private List <string> GetNodeReferences(ScenarioData.ScenarioObject objectType, string permutation)
{
var nodeIds = new List <string>();
// Add geometry instances to the node
if (!TagIndex.IsValid(objectType.ObjectTagDatum))
{
throw new ColladaException("Failed to load the object type tag {0}", objectType.ObjectTagPath);
}
var objectName = Path.GetFileNameWithoutExtension(objectType.ObjectTagPath);
objectName += "-perm" + permutation;
// Collect data about the object
var objectData = new ObjectData();
objectData.CollectData(mTagIndex, mTagIndex[objectType.ObjectTagDatum]);
if (!TagIndex.IsValid(objectData.Model))
{
return(nodeIds);
}
if (COLLADAFile.LibraryNodes == null)
{
AddLibraryNodes();
}
// Collect data about the model
var modelData = new ModelData();
modelData.CollectData(mTagIndex, mTagIndex[objectData.Model]);
// Get all of the geometries that make up the permutation at the highest lod
var geometryList = modelData.GetGeometries(permutation, Blam.Halo1.TypeEnums.LevelOfDetailEnum.SuperHigh);
// Add geometry instances for all geometries
foreach (var geometrySet in geometryList)
{
var name = objectName + "-" + geometrySet.Name;
ColladaNCName nodeName = name;
ColladaID <ColladaNode> nodeId = name;
nodeIds.Add(nodeId);
if (COLLADAFile.LibraryNodes.Node.Exists(node => node.ID == nodeId.ToString()))
{
break;
}
// Create shader references for all shaders used by the geometry
var materialReferences = new MaterialReferenceList();
foreach (var shader in geometrySet.Shaders)
{
ColladaNCName symbolName = shader.MaterialName;
ColladaID <Fx.ColladaMaterial> shaderName = shader.MaterialName;
var url = ColladaUtilities.BuildExternalReference(modelData,
colladaSettings.RootDirectory,
shaderName);
materialReferences.Add(new MaterialReference(shaderName, url, symbolName));
}
// Build the geometry reference URL and add the geometry instance
string geometryURL = ColladaUtilities.BuildExternalReference(modelData,
colladaSettings.RootDirectory,
new ColladaID <Core.ColladaGeometry>(geometrySet.Name));
var nodeType = CreateNode(nodeName, "", nodeId, Enums.ColladaNodeType.NODE);
nodeType.Add(CreateInstanceGeometry(geometryURL, geometrySet.Name, materialReferences));
COLLADAFile.LibraryNodes.Node.Add(nodeType);
}
return(nodeIds);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Exports the provided bsp's lightmap sizes with a multiplier. </summary>
///
/// <param name="tagIndex"> Tag index the bsp belongs to. </param>
/// <param name="tagManager"> The bsp tag's manager. </param>
/// <param name="sizeMultiplier"> The lightmap size multiplier. </param>
/// <param name="outputFile"> The bsp's output file. </param>
public void Export(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager, int sizeMultiplier, string outputFile)
{
// Collect the necessary data
var structureBSP = tagManager.TagDefinition as BlamLib.Blam.Halo1.Tags.structure_bsp_group;
if (!TagIndex.IsValid(structureBSP.LightmapBitmaps.Datum))
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
var bitmapManager = tagIndex[structureBSP.LightmapBitmaps.Datum];
if (bitmapManager == null)
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
if (structureBSP.Lightmaps.Count == 0)
{
mMessageHandler.SendMessage("BSP has no lightmaps {0}", tagManager.Name);
return;
}
var bitmap = bitmapManager.TagDefinition as BlamLib.Blam.Halo1.Tags.bitmap_group;
if (bitmap == null)
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
// Build the lightmap size list
var lightmapSizeList = new List <string>();
var bspName = Path.GetFileNameWithoutExtension(tagManager.Name);
foreach (var lightmap in structureBSP.Lightmaps)
{
if (lightmap.Bitmap.Value == -1)
{
continue;
}
if (lightmap.Bitmap.Value >= bitmap.Bitmaps.Count)
{
mMessageHandler.SendMessage("Failed to export lightmap sizes. A lightmap bitmap and bsp do not have matching lightmap counts {0}", tagManager.Name);
return;
}
var bitmapInfo = bitmap.Bitmaps[lightmap.Bitmap.Value];
lightmapSizeList.Add(String.Format("{0}_{1}\t[{2},{3}]"
, bspName
, lightmap.Bitmap.Value
, bitmapInfo.Width * sizeMultiplier
, bitmapInfo.Height * sizeMultiplier));
}
// Save the sizes to file
var sizeFileName = Path.ChangeExtension(outputFile, "lmsz");
try
{
using (var outputStream = File.OpenWrite(sizeFileName))
{
var writer = new StreamWriter(outputStream);
writer.Write(String.Join("\r\n", lightmapSizeList));
writer.Flush();
}
mMessageHandler.SendMessage("BSP lightmap sizes saved");
}
catch (IOException)
{
mMessageHandler.SendMessage("Failed to open the lightmap sizes file");
}
}
