public RunDelegateScript(WorldModel worldModel, IFunction<Element> obj, IFunction<string> del, IList<IFunction<object>> parameters)
{
m_worldModel = worldModel;
m_delegate = del;
m_parameters = new FunctionCallParameters(worldModel, parameters);
m_appliesTo = obj;
}
public SetFieldScript(WorldModel worldModel, IFunction<Element> obj, IFunction<string> field, IFunction<object> value)
{
m_worldModel = worldModel;
m_obj = obj;
m_field = field;
m_value = value;
}
public RequestScript(ScriptContext scriptContext, string request, IFunction<string> data)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_data = data;
m_request = (Request)(Enum.Parse(typeof(Request), request));
}
public ForEachScript(WorldModel worldModel, string variable, IFunctionGeneric list, IScript loopScript)
{
m_worldModel = worldModel;
m_variable = variable;
m_list = list;
m_loopScript = loopScript;
}
public CreateExitScript(WorldModel worldModel, IFunction<string> name, IFunction<Element> from, IFunction<Element> to)
{
m_worldModel = worldModel;
m_name = name;
m_from = from;
m_to = to;
}
public PlaySoundScript(WorldModel worldModel, IFunction<string> function, IFunction<bool> synchronous, IFunction<bool> loop)
{
m_worldModel = worldModel;
m_filename = function;
m_synchronous = synchronous;
m_loop = loop;
}
public ListAddScript(ScriptContext scriptContext, IFunctionGeneric list, IFunction<object> value)
{
m_scriptContext = scriptContext;
m_list = list;
m_value = value;
m_worldModel = scriptContext.WorldModel;
}
public DictionaryAddScript(WorldModel worldModel, IFunctionGeneric dictionary, IFunction<string> key, IFunction<object> value)
{
m_dictionary = dictionary;
m_key = key;
m_value = value;
m_worldModel = worldModel;
}
public GetInputScript(ScriptContext scriptContext, IScriptFactory scriptFactory, IScript callbackScript)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_scriptFactory = scriptFactory;
m_callbackScript = callbackScript;
}
public DoActionScript(ScriptContext scriptContext, IFunction<Element> obj, IFunction<string> action)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_obj = obj;
m_action = action;
}
public IfScript(IFunction<bool> expression, IScript thenScript, IScript elseScript, WorldModel worldModel)
{
m_expression = expression;
m_thenScript = thenScript;
m_elseScript = elseScript;
m_worldModel = worldModel;
}
public LazyLoadScript(ScriptFactory scriptFactory, string scriptString, ScriptContext scriptContext)
{
m_scriptFactory = scriptFactory;
m_scriptString = scriptString;
m_scriptContext = scriptContext;
m_worldModel = scriptFactory.WorldModel;
}
public UseSkillButtonGump(SkillEntry skill)
: base(skill.ID, 0)
{
while (UserInterface.GetControl<UseSkillButtonGump>(skill.ID) != null)
{
UserInterface.GetControl<UseSkillButtonGump>(skill.ID).Dispose();
}
m_Skill = skill;
m_World = ServiceRegistry.GetService<WorldModel>();
IsMoveable = true;
HandlesMouseInput = true;
m_BG = new ResizePic[3];
m_BG[0] = (ResizePic)AddControl(new ResizePic(this, 0, 0, 0x24B8, 120, 40));
m_BG[1] = (ResizePic)AddControl(new ResizePic(this, 0, 0, 0x24EA, 120, 40));
m_BG[2] = (ResizePic)AddControl(new ResizePic(this, 0, 0, 0x251C, 120, 40));
m_Caption = (HtmlGumpling)AddControl(new HtmlGumpling(this, 0, 10, 120, 20, 0, 0, "<center>" + m_Skill.Name));
for (int i = 0; i < 3; i++)
{
m_BG[i].MouseDownEvent += EventMouseDown;
m_BG[i].MouseUpEvent += EventMouseUp;
m_BG[i].MouseClickEvent += EventMouseClick;
}
}
/**
* Instantiate the world model (if a prefab for it exists)
* and parent it to the given transform
*/
public virtual bool ActivateWorldModel(Transform worldModelParent)
{
if (worldModelPrefab == null)
return false;
worldModel = (WorldModel)Instantiate(worldModelPrefab, worldModelParent.position, worldModelParent.rotation);
worldModel.transform.parent = worldModelParent;
return true;
}
public WhileScript(ScriptContext scriptContext, IScriptFactory scriptFactory, IFunction<bool> expression, IScript loopScript)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_scriptFactory = scriptFactory;
m_expression = expression;
m_loopScript = loopScript;
}
public RunDelegateScript(ScriptContext scriptContext, IFunction<Element> obj, IFunction<string> del, IList<IFunction<object>> parameters)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_delegate = del;
m_parameters = new FunctionCallParameters(m_worldModel, parameters);
m_appliesTo = obj;
}
public DictionaryAddScript(ScriptContext scriptContext, IFunctionGeneric dictionary, IFunction<string> key, IFunction<object> value)
{
m_scriptContext = scriptContext;
m_dictionary = dictionary;
m_key = key;
m_value = value;
m_worldModel = scriptContext.WorldModel;
}
public PaperDollInteractable(AControl parent, int x, int y)
: base(0, 0)
{
Parent = parent;
Position = new Point(x, y);
m_World = ServiceRegistry.GetService<WorldModel>();
}
public SetFieldScript(ScriptContext scriptContext, IFunction<Element> obj, IFunction<string> field, IFunction<object> value)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_obj = obj;
m_field = field;
m_value = value;
}
public AskScript(ScriptContext scriptContext, IScriptFactory scriptFactory, IFunction<string> caption, IScript callbackScript)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_scriptFactory = scriptFactory;
m_caption = caption;
m_callbackScript = callbackScript;
}
public PlaySoundScript(ScriptContext scriptContext, IFunction<string> function, IFunction<bool> synchronous, IFunction<bool> loop)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_filename = function;
m_synchronous = synchronous;
m_loop = loop;
}
public WorldCursor(WorldModel model)
{
m_Network = ServiceRegistry.GetService<INetworkClient>();
m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>();
m_Input = ServiceRegistry.GetService<InputManager>();
m_World = model;
InternalRegisterInteraction();
}
public ScriptContext(WorldModel worldModel, bool createEditorExpressionContext)
{
m_worldModel = worldModel;
if (createEditorExpressionContext)
{
InitialiseExpressionContext();
}
}
public ForScript(WorldModel worldModel, IScriptFactory scriptFactory, string variable, IFunction<int> from, IFunction<int> to, IScript loopScript)
{
m_worldModel = worldModel;
m_scriptFactory = scriptFactory;
m_variable = variable;
m_from = from;
m_to = to;
m_loopScript = loopScript;
}
public WorldInput(WorldModel world)
{
World = world;
m_Network = ServiceRegistry.GetService<INetworkClient>();
m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>();
m_Input = ServiceRegistry.GetService<InputManager>();
MousePick = new MousePicking();
}
public ShowMenuScript(ScriptContext scriptContext, IScriptFactory scriptFactory, IFunction<string> caption, IFunctionGeneric options, IFunction<bool> allowCancel, IScript callbackScript)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_scriptFactory = scriptFactory;
m_caption = caption;
m_options = options;
m_allowCancel = allowCancel;
m_callbackScript = callbackScript;
}
public MiniMapGump()
: base(0, 0)
{
m_World = ServiceRegistry.GetService<WorldModel>();
m_useLargeMap = MiniMap_LargeFormat;
IsMoveable = true;
MakeThisADragger();
}
public FunctionCallScript(WorldModel worldModel, string procedure, IList<IFunction<object>> parameters, IScript paramFunction)
{
m_worldModel = worldModel;
m_procedure = procedure;
m_parameters = new FunctionCallParameters(worldModel, parameters);
m_paramFunction = paramFunction;
m_parameters.ParametersAsQuestList.Added += Parameters_Added;
m_parameters.ParametersAsQuestList.Removed += Parameters_Removed;
}
public SkillsGump()
: base(0, 0)
{
IsMoveable = true;
m_World = ServiceRegistry.GetService<WorldModel>();
AddControl(m_Background = new ExpandableScroll(this, 0, 0, 200));
m_Background.TitleGumpID = 0x834;
AddControl(m_SkillsHtml = new HtmlGumpling(this, 32, 32, 240, 200 - 92, 0, 2, string.Empty));
m_SkillsHtml.OnDragHRef += OnSkillDrag;
}
public FunctionCallParameters(WorldModel worldModel, IList<IFunction<object>> parameters)
{
m_parameterStrings.UndoLog = worldModel.UndoLogger;
m_parameters = parameters;
if (parameters != null)
{
foreach (var param in parameters)
{
string paramString = param.Save();
m_parameterStrings.Add(paramString);
}
}
}
/**************************************************************************/
public bool loadVMap(uint mapID, uint tileX, uint tileY, MeshData meshData)
{
var vmapManager = new VMapManager2();
VMAPLoadResult result = vmapManager.loadMap("vmaps", mapID, tileX, tileY);
bool retval = false;
do
{
if (result == 0)
{
break;
}
Dictionary <uint, StaticMapTree> instanceTrees;
vmapManager.getInstanceMapTree(out instanceTrees);
if (instanceTrees[mapID] == null)
{
break;
}
ModelInstance[] models = null;
uint count;
instanceTrees[mapID].getModelInstances(out models, out count);
if (models == null)
{
break;
}
for (uint i = 0; i < count; ++i)
{
ModelInstance instance = models[i];
if (instance == null)
{
continue;
}
// model instances exist in tree even though there are instances of that model in this tile
WorldModel worldModel = instance.getWorldModel();
if (worldModel == null)
{
continue;
}
// now we have a model to add to the meshdata
retval = true;
List <GroupModel> groupModels;
worldModel.getGroupModels(out groupModels);
// all M2s need to have triangle indices reversed
bool isM2 = instance.name.Contains(".m2") || instance.name.Contains(".M2");
// transform data
float scale = instance.iScale;
Matrix3 rotation = Matrix3.fromEulerAnglesXYZ(MathF.PI * instance.iRot.Z / -180.0f, MathF.PI * instance.iRot.X / -180.0f, MathF.PI * instance.iRot.Y / -180.0f);
Vector3 position = instance.iPos;
position.X -= 32 * SharedConst.GRID_SIZE;
position.Y -= 32 * SharedConst.GRID_SIZE;
foreach (var it in groupModels)
{
List <Vector3> tempVertices;
List <Vector3> transformedVertices = new List <Vector3>();
List <MeshTriangle> tempTriangles;
WmoLiquid liquid = null;
it.getMeshData(out tempVertices, out tempTriangles, out liquid);
// first handle collision mesh
transform(tempVertices.ToArray(), transformedVertices, scale, rotation, position);
int offset = meshData.solidVerts.Count / 3;
copyVertices(transformedVertices.ToArray(), meshData.solidVerts);
copyIndices(tempTriangles, meshData.solidTris, offset, isM2);
// now handle liquid data
if (liquid != null)
{
List <Vector3> liqVerts = new List <Vector3>();
List <uint> liqTris = new List <uint>();
uint tilesX, tilesY, vertsX, vertsY;
Vector3 corner;
liquid.getPosInfo(out tilesX, out tilesY, out corner);
vertsX = tilesX + 1;
vertsY = tilesY + 1;
byte[] flags = liquid.iFlags;
float[] data = liquid.iHeight;
NavTerrain type = NavTerrain.Empty;
// convert liquid type to NavTerrain
switch (liquid.iType & 3)
{
case 0:
case 1:
type = NavTerrain.Water;
break;
case 2:
type = NavTerrain.Magma;
break;
case 3:
type = NavTerrain.Slime;
break;
}
// indexing is weird...
// after a lot of trial and error, this is what works:
// vertex = y*vertsX+x
// tile = x*tilesY+y
// flag = y*tilesY+x
Vector3 vert;
for (uint x = 0; x < vertsX; ++x)
{
for (uint y = 0; y < vertsY; ++y)
{
vert = new Vector3(corner.X + x * SharedConst.GRID_PART_SIZE, corner.Y + y * SharedConst.GRID_PART_SIZE, data[y * vertsX + x]);
vert = vert * rotation * scale + position;
vert.X *= -1.0f;
vert.Y *= -1.0f;
liqVerts.Add(vert);
}
}
uint idx1, idx2, idx3, idx4;
uint square;
for (uint x = 0; x < tilesX; ++x)
{
for (uint y = 0; y < tilesY; ++y)
{
if ((flags[x + y * tilesX] & 0x0f) != 0x0f)
{
square = x * tilesY + y;
idx1 = square + x;
idx2 = square + 1 + x;
idx3 = square + tilesY + 1 + 1 + x;
idx4 = square + tilesY + 1 + x;
// top triangle
liqTris.Add(idx3);
liqTris.Add(idx2);
liqTris.Add(idx1);
// bottom triangle
liqTris.Add(idx4);
liqTris.Add(idx3);
liqTris.Add(idx1);
}
}
}
int liqOffset = meshData.liquidVerts.Count / 3;
for (int x = 0; x < liqVerts.Count; ++x)
{
meshData.liquidVerts.Add(liqVerts[x].Y);
meshData.liquidVerts.Add(liqVerts[x].Z);
meshData.liquidVerts.Add(liqVerts[x].X);
}
for (int x = 0; x < liqTris.Count / 3; ++x)
{
meshData.liquidTris.Add((int)(liqTris[x * 3 + 1] + liqOffset));
meshData.liquidTris.Add((int)(liqTris[x * 3 + 2] + liqOffset));
meshData.liquidTris.Add((int)(liqTris[x * 3] + liqOffset));
meshData.liquidType.Add((byte)type);
}
}
}
}
}while (false);
vmapManager.unloadMap(mapID, tileX, tileY);
return(retval);
}
public override float GetHValue(WorldModel worldModel)
{
var mana = (int)worldModel.GetProperty(Properties.MANA);
return(base.GetHValue(worldModel) * mana);
}
private void DrawWorldEntry(WorldItem world)
{
string authorName = world.Author.Username;
BeginHorizontal(world.World == Selected ? EntryHoverStyle : EntryStyle, Height(68));
{
Box("", Width(60), Height(60));
BeginVertical();
{
Label($"<b><size=16>{world.World.Title}</size></b>");
Label("by " + authorName, WorldInfoStyle);
Label($"{world.World.Downloads} downloads", WorldInfoStyle);
}
EndVertical();
string btnText =
world.State == WorldState.Downloading ? "Downloading..." :
world.State == WorldState.Existing ? "Play" : "Download";
GUI.enabled = world.State != WorldState.Downloading;
FlexibleSpace();
BeginVertical();
{
FlexibleSpace();
BeginHorizontal();
{
FlexibleSpace();
//--Manage button--
if (world.Author.ID == Remote.User.CurrentUser.ID && Button("Manage", Height(30)))
{
ShareMod.PlayButtonSound();
if (!Managing.Any(o => o.World.ID == world.World.ID))
{
ShowManageWorld(world.World);
}
}
//------------
//--Download button--
if (Button(btnText, Height(30), Width(95)))
{
ShareMod.PlayButtonSound();
Selected = world.World;
if (world.State == WorldState.Existing)
{
Hide();
LoadWorld(world.World);
}
else
{
DownloadWorld(world);
}
}
//------------
}
EndHorizontal();
Space(5);
GUI.enabled = false;
string time = world.TimeString;
Label(time, WorldIDStyle);
FlexibleSpace();
GUI.enabled = true;
}
EndVertical();
}
EndHorizontal();
Rect horRect = GUILayoutUtility.GetLastRect();
if (Event.current.isMouse && horRect.Contains(Event.current.mousePosition) && Event.current.button == 0)
{
Selected = world.World;
}
}
internal LazyFields(WorldModel worldModel, Fields fields)
{
m_worldModel = worldModel;
m_fields = fields;
}
public override float GetHValue(WorldModel worldModel)
{
return(base.GetHValue(worldModel));
}
public PaperDollGump(Mobile parent)
: base(0, 0)
{
Parent = parent;
m_UserInterface = UltimaServices.GetService <UserInterfaceService>();
m_World = UltimaServices.GetService <WorldModel>();
m_Client = UltimaServices.GetService <INetworkClient>();
IsMovable = true;
if (parent == (Mobile)EntityManager.GetPlayerObject())
{
AddControl(new GumpPic(this, 0, 0, 0, 0x07d0, 0));
LastControl.MakeDragger(this);
LastControl.MakeCloseTarget(this);
// HELP
AddControl(new Button(this, 0, 185, 44 + 27 * 0, 0x07ef, 0x07f0, ButtonTypes.Activate, 0,
(int)Buttons.Help));
((Button)LastControl).GumpOverID = 0x07f1;
// OPTIONS
AddControl(new Button(this, 0, 185, 44 + 27 * 1, 0x07d6, 0x07d7, ButtonTypes.Activate, 0,
(int)Buttons.Options));
((Button)LastControl).GumpOverID = 0x07d8;
// LOG OUT
AddControl(new Button(this, 0, 185, 44 + 27 * 2, 0x07d9, 0x07da, ButtonTypes.Activate, 0,
(int)Buttons.LogOut));
((Button)LastControl).GumpOverID = 0x07db;
// QUESTS
AddControl(new Button(this, 0, 185, 44 + 27 * 3, 0x57b5, 0x57b7, ButtonTypes.Activate, 0,
(int)Buttons.Quests));
((Button)LastControl).GumpOverID = 0x57b6;
// SKILLS
AddControl(new Button(this, 0, 185, 44 + 27 * 4, 0x07df, 0x07e0, ButtonTypes.Activate, 0,
(int)Buttons.Skills));
((Button)LastControl).GumpOverID = 0x07e1;
// GUILD
AddControl(new Button(this, 0, 185, 44 + 27 * 5, 0x57b2, 0x57b4, ButtonTypes.Activate, 0,
(int)Buttons.Guild));
((Button)LastControl).GumpOverID = 0x57b3;
// PEACE / WAR
AddControl(new Button(this, 0, 185, 44 + 27 * 6, 0x07e5, 0x07e6, ButtonTypes.Activate, 0,
(int)Buttons.PeaceWarToggle));
((Button)LastControl).GumpOverID = 0x07e7;
// STATUS
AddControl(new Button(this, 0, 185, 44 + 27 * 7, 0x07eb, 0x07ec, ButtonTypes.Activate, 0,
(int)Buttons.Status));
((Button)LastControl).GumpOverID = 0x07ed;
// Paperdoll
AddControl(new PaperDollInteractable(this, 0, 8, 21)
{
SourceEntity = Parent
});
}
else
{
AddControl(new GumpPic(this, 0, 0, 0, 0x07d1, 0));
LastControl.MakeDragger(this);
LastControl.MakeCloseTarget(this);
// Paperdoll
AddControl(new PaperDollInteractable(this, 0, 8, 21)
{
SourceEntity = Parent
});
}
}
public InvokeScript(ScriptContext scriptContext, IFunction <IScript> script)
{
m_scriptContext = scriptContext;
m_worldModel = scriptContext.WorldModel;
m_script = script;
}
/*
* This method is called once for every turn.
* It returns an empty command. For a more interesting example, see the python sample solution.
*
* Parameters:
* wm - an instance of the WorldModel class that contains a property called Players which is a List of Players.
* A Player has a property named Body which is a List of Coordinates,
* and which represent the coordinates of the body parts of the snake, in order.
* A Coordinate has two properties, X and Y, of type int.
* turn - the index of the turn.
* If you receive twice the same number, don't worry, just ignore it.
*
* Returns:
* A Command instance - a Command contains a property called Direction of type enum Direction.
* Direction values: RIGHT, UP, LEFT, DOWN.
*/
public Command playTurn(WorldModel wm, int turn)
{
return(null);
}
public override bool CanExecute(WorldModel worldModel)
{
return(base.CanExecute(worldModel));
}
public EntityManager(WorldModel model)
{
m_Model = model;
}
internal abstract float EvaluateValue(WorldModel model, Dictionary <Role, Character> involvedCharacters);
protected override void OnInitialize()
{
m_Model = Service.Get <WorldModel>();
}
public override float GetDuration(WorldModel worldModel)
{
var position = (Vector3)worldModel.GetProperty(Properties.POSITION);
return(this.GetDuration(position));
}
public ManageWorldUI(Remote remote, WorldModel world) : base(remote)
{
this.World = world;
this.WindowRect = new Rect(Screen.width / 2 - WindowRect.width / 2, Screen.height / 2 - WindowRect.height / 2, WindowRect.width, WindowRect.height);
}
public void SetModel(WorldModel model)
{
_model = model;
}
public void DoRedo(WorldModel worldModel)
{
worldModel.Object(m_appliesTo).Fields.RemoveFieldInternal(m_property);
}
public Packager(WorldModel worldModel)
{
m_worldModel = worldModel;
}
internal override float EvaluateValue(WorldModel model, Dictionary <Role, Character> involvedCharacters)
{
throw new NotImplementedException();
}
public void DoUndo(WorldModel worldModel)
{
worldModel.Object(m_appliesTo).Fields.SetFromUndo(m_property, m_oldValue);
}
public override float GetDuration(WorldModel worldModel)
{
return(0.0f);
}
public static WorldModel LoadWMO(string filename, CacheStorage cache, int modelShader)
{
if (cache.worldModelBatches.ContainsKey(filename))
{
return(cache.worldModelBatches[filename]);
}
WoWFormatLib.Structs.WMO.WMO wmo = new WoWFormatLib.Structs.WMO.WMO();
if (cache.worldModels.ContainsKey(filename))
{
wmo = cache.worldModels[filename];
}
else
{
//Load WMO from file
if (WoWFormatLib.Utils.CASC.FileExists(filename))
{
var wmoreader = new WMOReader();
wmoreader.LoadWMO(filename, false);
cache.worldModels.Add(filename, wmoreader.wmofile);
wmo = wmoreader.wmofile;
}
else
{
throw new Exception("WMO " + filename + " does not exist!");
}
}
var wmobatch = new WorldModel();
wmobatch.groupBatches = new WorldModelGroupBatches[wmo.group.Count()];
string[] groupNames = new string[wmo.group.Count()];
for (int g = 0; g < wmo.group.Count(); g++)
{
if (wmo.group[g].mogp.vertices == null)
{
continue;
}
for (int i = 0; i < wmo.groupNames.Count(); i++)
{
if (wmo.group[g].mogp.nameOffset == wmo.groupNames[i].offset)
{
groupNames[g] = wmo.groupNames[i].name.Replace(" ", "_");
}
}
if (groupNames[g] == "antiportal")
{
continue;
}
// GL.UseProgram(modelShader);
wmobatch.groupBatches[g].vao = GL.GenVertexArray();
Console.WriteLine("Generated WMO VAO " + wmobatch.groupBatches[g].vao);
GL.BindVertexArray(wmobatch.groupBatches[g].vao);
wmobatch.groupBatches[g].vertexBuffer = GL.GenBuffer();
wmobatch.groupBatches[g].indiceBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, wmobatch.groupBatches[g].vertexBuffer);
M2Vertex[] wmovertices = new M2Vertex[wmo.group[g].mogp.vertices.Count()];
for (int i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
wmovertices[i].Position = new Vector3(wmo.group[g].mogp.vertices[i].vector.X, wmo.group[g].mogp.vertices[i].vector.Y, wmo.group[g].mogp.vertices[i].vector.Z);
wmovertices[i].Normal = new Vector3(wmo.group[g].mogp.normals[i].normal.X, wmo.group[g].mogp.normals[i].normal.Y, wmo.group[g].mogp.normals[i].normal.Z);
if (wmo.group[g].mogp.textureCoords[0] == null)
{
wmovertices[i].TexCoord = new Vector2(0.0f, 0.0f);
}
else
{
wmovertices[i].TexCoord = new Vector2(wmo.group[g].mogp.textureCoords[0][i].X, wmo.group[g].mogp.textureCoords[0][i].Y);
}
}
//Push to buffer
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(wmovertices.Length * 8 * sizeof(float)), wmovertices, BufferUsageHint.StaticDraw);
//Switch to Index buffer
GL.BindBuffer(BufferTarget.ElementArrayBuffer, wmobatch.groupBatches[g].indiceBuffer);
List <uint> wmoindicelist = new List <uint>();
for (int i = 0; i < wmo.group[g].mogp.indices.Count(); i++)
{
wmoindicelist.Add(wmo.group[g].mogp.indices[i].indice);
}
wmobatch.groupBatches[g].indices = wmoindicelist.ToArray();
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(wmobatch.groupBatches[g].indices.Length * sizeof(uint)), wmobatch.groupBatches[g].indices, BufferUsageHint.StaticDraw);
var texCoordLoc = GL.GetAttribLocation(modelShader, "vTexCoord");
GL.EnableVertexAttribArray(texCoordLoc);
GL.VertexAttribPointer(texCoordLoc, 2, VertexAttribPointerType.Float, false, 8 * sizeof(float), 3 * sizeof(float));
var posLoc = GL.GetAttribLocation(modelShader, "vPosition");
GL.EnableVertexAttribArray(posLoc);
GL.VertexAttribPointer(posLoc, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 5 * sizeof(float));
GL.BindVertexArray(0);
}
wmobatch.mats = new Material[wmo.materials.Count()];
for (int i = 0; i < wmo.materials.Count(); i++)
{
for (int ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == wmo.materials[i].texture1)
{
wmobatch.mats[i].texture1 = wmo.materials[i].texture1;
wmobatch.mats[i].textureID = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
wmobatch.mats[i].filename = wmo.textures[ti].filename;
}
}
}
/*
* wmobatch.doodads = new WMODoodad[wmo.doodadDefinitions.Count()];
*
* for(int i = 0; i < wmo.doodadDefinitions.Count(); i++)
* {
* for(int j = 0; j < wmo.doodadNames.Count(); j++)
* {
* if (wmo.doodadDefinitions[i].offset == wmo.doodadNames[j].startOffset)
* {
* wmobatch.doodads[i].filename = wmo.doodadNames[j].filename;
* M2Loader.LoadM2(wmobatch.doodads[i].filename, cache);
* }
* }
* wmobatch.doodads[i].flags = wmo.doodadDefinitions[i].flags;
* wmobatch.doodads[i].position = new Vector3(wmo.doodadDefinitions[i].position.X, wmo.doodadDefinitions[i].position.Y, wmo.doodadDefinitions[i].position.Z);
* wmobatch.doodads[i].rotation = new Quaternion(wmo.doodadDefinitions[i].rotation.X, wmo.doodadDefinitions[i].rotation.Y, wmo.doodadDefinitions[i].rotation.Z, wmo.doodadDefinitions[i].rotation.W);
* wmobatch.doodads[i].scale = wmo.doodadDefinitions[i].scale;
* wmobatch.doodads[i].color = new Vector4(wmo.doodadDefinitions[i].color[0], wmo.doodadDefinitions[i].color[1], wmo.doodadDefinitions[i].color[2], wmo.doodadDefinitions[i].color[3]);
* }
*/
int numRenderbatches = 0;
//Get total amount of render batches
for (int i = 0; i < wmo.group.Count(); i++)
{
if (wmo.group[i].mogp.renderBatches == null)
{
continue;
}
numRenderbatches = numRenderbatches + wmo.group[i].mogp.renderBatches.Count();
}
wmobatch.wmoRenderBatch = new RenderBatch[numRenderbatches];
int rb = 0;
for (int g = 0; g < wmo.group.Count(); g++)
{
var group = wmo.group[g];
if (group.mogp.renderBatches == null)
{
continue;
}
for (int i = 0; i < group.mogp.renderBatches.Count(); i++)
{
wmobatch.wmoRenderBatch[rb].firstFace = group.mogp.renderBatches[i].firstFace;
wmobatch.wmoRenderBatch[rb].numFaces = group.mogp.renderBatches[i].numFaces;
uint matID = 0;
if (group.mogp.renderBatches[i].flags == 2)
{
matID = (uint)group.mogp.renderBatches[i].possibleBox2_3;
}
else
{
matID = group.mogp.renderBatches[i].materialID;
}
for (int ti = 0; ti < wmobatch.mats.Count(); ti++)
{
if (wmo.materials[matID].texture1 == wmobatch.mats[ti].texture1)
{
wmobatch.wmoRenderBatch[rb].materialID = new uint[] { (uint)wmobatch.mats[ti].textureID };
}
}
wmobatch.wmoRenderBatch[rb].blendType = wmo.materials[group.mogp.renderBatches[i].materialID].blendMode;
wmobatch.wmoRenderBatch[rb].groupID = (uint)g;
rb++;
}
}
cache.worldModelBatches.Add(filename, wmobatch);
return(wmobatch);
}
public ExpressionOwner(WorldModel worldModel)
{
m_worldModel = worldModel;
}
public override bool CanExecute(WorldModel worldModel)
{
return(base.CanExecute() && (int)worldModel.GetProperty(Properties.MANA) >= 5);
}
public RemoveProjectileCommand(IProjectile projectile, WorldModel worldModel)
{
_worldModel = worldModel;
_projectile = projectile;
}
private void InitialUI_Load(object sender, EventArgs e)
{
m_worldModel = new WorldModel(m_data, SimCountryData.LoadFrom(@"../../../Data/CountryData.dat"));
m_mapControl.AssignWorldModel(m_worldModel);
PlotForm dc1 = new PlotForm("Mortality");
dc1.Bind(m_worldModel,
new[] {
GetTotal(n => n.Killed),
GetTotal(n => n.Dead)
},
new[] {
"Killed",
"Dead"
});
PlotForm dc2 = new PlotForm("Disease Stages");
dc2.Bind(m_worldModel,
new[] {
GetTotal(n => n.ContagiousAsymptomatic),
GetTotal(n => n.ContagiousSymptomatic),
GetTotal(n => n.NonContagiousInfected),
GetTotal(n => n.Immune),
},
new[]
{
"ContagiousAsymptomatic",
"ContagiousSymptomatic",
"NonContagiousInfected",
"Immune"
});
m_mapControl.Show();
dc1.Show();
dc2.Show();
/*PlotForm m_plotWindow1 = new PlotForm("Killed");
* m_plotWindow1.Bind(m_worldModel, GetTotal(n => n.Killed));
* m_plotWindow1.Show();
*
* PlotForm m_plotWindow2 = new PlotForm("Immune");
* m_plotWindow2.Bind(m_worldModel, GetTotal(n => n.Immune));
* m_plotWindow2.Show();
*
* PlotForm m_plotWindow3 = new PlotForm("Total Population");
* m_plotWindow3.Bind(m_worldModel, GetTotal(n => n.Population));
* m_plotWindow3.Show();
*
* PlotForm m_plotWindow4 = new PlotForm("Immunization Effort");
* m_plotWindow4.Bind(m_worldModel, GetTotal(n => n.Flows[2](n)));
* m_plotWindow4.Show();*/
m_mapControl.MouseMove += (o, args) =>
{
double lat, lon;
int x, y;
GraphicalUtilities.GraphicsCoordsToMapCoords(panel1.Size, m_worldModel.Size, args.X, args.Y, out x,
out y);
m_data.DataXYToLatLon(x, y, out lat, out lon);
string where = ReverseGeocodeService.CountryNameForLatAndLong(lat, lon + 2) ?? "Unknown";
DiseaseNode n = m_worldModel.NodeAt(x, y);
toolStripStatusLabel1.Text = $"data[{x},{y}] is {where}, Lat {lat:f2}/Lon {lon:f2} {n:d4}";
Console.WriteLine(toolStripStatusLabel1.Text);
};
toolStripStatusLabel1.TextChanged += (o, args) => Console.WriteLine(((ToolStripStatusLabel)o).Text);
}
public void DoRedo(WorldModel worldModel)
{
worldModel.Object(m_appliesTo).Fields.DoUndoAddRemoveType(m_newValue);
}
protected virtual Reward Playout(WorldModel initialPlayoutState)
{
//TODO: implement
throw new NotImplementedException();
}
public FoeDetectorAbility(UnitModel unit, AbilityData data, WorldModel world)
{
_unit = unit;
_world = world;
_data = new FoeDetectorAbilityParams(data);
}
private void SaveWorld(WorldModel world, byte[] data)
{
MemoryStream inStream = new MemoryStream(data);
Zipper.ExtractZipFile(inStream, SavesPath + world.Title);
}
protected PlatformManager(WorldModel model)
{
_model = model;
}
