protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
ModelBuilderHelper.DecimalPrecisionConfiguration(modelBuilder);
ModelBuilderHelper.RowVersionConfiguration(modelBuilder);
ModelBuilderHelper.StringConfiguration(modelBuilder);
modelBuilder.Filter(DataFilters.MustHaveAgency, (Lib.IMustHaveAgency entity, int AgenciaId)
=> entity.AgenciaId == AgenciaId, 0);
}
public ModelLoaderData Load(Engine.GraphicFactory factory, Engine.GraphicInfo info, string Name)
{
modelNames.Add(Name);
ModelLoaderData ModelLoaderData = new ModelLoaderData();
Model model = factory.GetModel(Name);
Matrix[] m = new Matrix[model.Bones.Count];
model.CopyAbsoluteBoneTransformsTo(m);
for (int i = 0; i < model.Meshes.Count; i++)
{
String name = model.Meshes[i].Name.Substring(5);
for (int j = 0; j < model.Meshes[i].MeshParts.Count; j++)
{
Matrix tr = m[model.Meshes[i].ParentBone.Index];
Vector3 scale;
Vector3 pos;
Quaternion ori;
tr.Decompose(out scale, out ori, out pos);
ObjectInformation mi = new ObjectInformation();
mi.modelName = name;
mi.meshPartIndex = j;
mi.meshIndex = i;
mi.position = pos;
mi.scale = scale;
mi.rotation = ori;
mi.ellasticity = -1;
mi.dinamicfriction = -1;
mi.staticfriction = -1;
mi.collisionType = "TriangleMesh";
mi.mass = 10;
ModelBuilderHelper.Extract(m, model.Meshes[i].MeshParts[j], out mi.batchInformation);
mi.batchInformation.ModelLocalTransformation = m[model.Meshes[i].ParentBone.Index];
mi.textureInformation = new Modelo.TextureInformation(false, factory, null, null, null, null);
mi.textureInformation.LoadTexture();
Effect effect = model.Meshes[i].MeshParts[j].Effect;
BasicEffect BasicEffect = effect as BasicEffect;
if (BasicEffect != null)
{
mi.textureInformation.SetTexture(BasicEffect.Texture, TextureType.DIFFUSE);
}
ModelLoaderData.ModelMeshesInfo.Add(mi);
}
}
return(ModelLoaderData);
}
/// <summary>
/// Loads the model.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="BatchInformations">The batch informations.</param>
/// <param name="TextureInformations">The texture informations.</param>
protected override void LoadModel(GraphicFactory factory, out BatchInformation[][] BatchInformations, out TextureInformation[][] TextureInformations)
{
skinnedModel = factory.GetAnimatedModel(Name);
ModelBuilderHelper.Extract(factory, out BatchInformations, out TextureInformations, skinnedModel.Model, _diffuseName, _bumpName, _specularName, _glowName, isInternal);
BoundingSphere sphere = new BoundingSphere();
foreach (var item in skinnedModel.Model.Meshes)
{
sphere = BoundingSphere.CreateMerged(sphere, item.BoundingSphere);
}
modelRadius = sphere.Radius;
}
public async Task <List <GarageDto> > GetGarageByUser(int userId)
{
List <GarageDto> garageList = new List <GarageDto>();
SqlDataReader reader = null;
using (SqlCommand oCommand = await base.GetCommandAsync())
{
try
{
oCommand.CommandType = CommandType.Text;
oCommand.CommandText = @"select * From garages g inner join [guardameLugarDB].[dbo].localidades l on g.localidad_garage = l.localidad_id
where garage_id in (select garage_id from garage_por_usuario where user_id = @user_id) order by l.nombre_localidad;" ;
oCommand.AddParameter("user_id", DbType.Int32, userId);
IAsyncResult asyncResult = ExecuteAsync(oCommand, "GetGarageByUser");
reader = oCommand.EndExecuteReader(asyncResult);
while (await reader.ReadAsync())
{
garageList.Add(ModelBuilderHelper.BuildGaragesData(reader));
}
return(garageList);
}
catch (Exception ex)
{
_logger.LogError(ex, GetType().Name + "." + MethodBase.GetCurrentMethod().Name);
throw new AggregateException(_classFullName + ".GetGarageByUser(int userId)", ex);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (!TransactionOpened())
{
base.CloseCommand();
}
}
}
}
public async Task <LogInDto> LogInUser(string user, string password)
{
LogInDto objUser = null;
SqlDataReader reader = null;
using (SqlCommand oCommand = await base.GetCommandAsync())
{
try
{
oCommand.CommandType = CommandType.Text;
oCommand.CommandText = @"SELECT * FROM usuarios WHERE mail = @user and contraseña = @password";
oCommand.AddParameter("user", DbType.String, user);
oCommand.AddParameter("password", DbType.String, password);
IAsyncResult asyncResult = ExecuteAsync(oCommand, "LogInUser");
reader = oCommand.EndExecuteReader(asyncResult);
while (await reader.ReadAsync())
{
objUser = ModelBuilderHelper.BuildUserData(reader);
}
return(objUser);
}
catch (Exception ex)
{
_logger.LogError(ex, GetType().Name + "." + MethodBase.GetCurrentMethod().Name);
throw new AggregateException(_classFullName + ".LogInUser(string user, string password)", ex);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (!TransactionOpened())
{
base.CloseCommand();
}
}
}
}
public async Task <GarageDto> GetGarageById(int garageId)
{
GarageDto garageDto = null;
SqlDataReader reader = null;
using (SqlCommand oCommand = await base.GetCommandAsync())
{
try
{
oCommand.CommandType = CommandType.Text;
oCommand.CommandText = @"SELECT * FROM garages g inner join [guardameLugarDB].[dbo].localidades l on g.localidad_garage = l.localidad_id where garage_id = @garage_id order by l.nombre_localidad ;";
oCommand.AddParameter("garage_id", DbType.Int32, garageId);
IAsyncResult asyncResult = ExecuteAsync(oCommand, "GetGarageById");
reader = oCommand.EndExecuteReader(asyncResult);
while (await reader.ReadAsync())
{
garageDto = ModelBuilderHelper.BuildGaragesData(reader);
}
return(garageDto);
}
catch (Exception ex)
{
_logger.LogError(ex, GetType().Name + "." + MethodBase.GetCurrentMethod().Name);
throw new AggregateException(_classFullName + ".Localidades()", ex);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (!TransactionOpened())
{
base.CloseCommand();
}
}
}
}
public async Task <List <GarageDto> > GetGarages(string query)
{
List <GarageDto> garageList = new List <GarageDto>();
SqlDataReader reader = null;
using (SqlCommand oCommand = await base.GetCommandAsync())
{
try
{
oCommand.CommandType = CommandType.Text;
oCommand.CommandText = query;
IAsyncResult asyncResult = ExecuteAsync(oCommand, "GetGarages");
reader = oCommand.EndExecuteReader(asyncResult);
while (await reader.ReadAsync())
{
garageList.Add(ModelBuilderHelper.BuildGaragesData(reader));
}
return(garageList);
}
catch (Exception ex)
{
_logger.LogError(ex, GetType().Name + "." + MethodBase.GetCurrentMethod().Name);
throw new AggregateException(_classFullName + ".GetGarages(string query)", ex);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (!TransactionOpened())
{
base.CloseCommand();
}
}
}
}
public async Task <List <LocalidadesDto> > Localidades()
{
List <LocalidadesDto> listaLocalidades = new List <LocalidadesDto>();
SqlDataReader reader = null;
using (SqlCommand oCommand = await base.GetCommandAsync())
{
try
{
oCommand.CommandType = CommandType.Text;
oCommand.CommandText = @"SELECT * FROM localidades;";
IAsyncResult asyncResult = ExecuteAsync(oCommand, "localidades");
reader = oCommand.EndExecuteReader(asyncResult);
while (await reader.ReadAsync())
{
listaLocalidades.Add(ModelBuilderHelper.BuildLocalidadesData(reader));
}
return(listaLocalidades);
}
catch (Exception ex)
{
_logger.LogError(ex, GetType().Name + "." + MethodBase.GetCurrentMethod().Name);
throw new AggregateException(_classFullName + ".Localidades()", ex);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (!TransactionOpened())
{
base.CloseCommand();
}
}
}
}
public static IObject[] CreateOBJ(IWorld world, GraphicFactory factory, GraphicInfo ginfo, ObjectInformation[] mi)
{
IModelo model = new CustomModel(factory, mi);
MaterialDescription material;
if (mi[0].staticfriction == -1 || mi[0].dinamicfriction == -1 || mi[0].ellasticity == -1)
{
material = MaterialDescription.DefaultBepuMaterial();
}
else
{
material = new MaterialDescription(mi[0].staticfriction, mi[0].dinamicfriction, mi[0].ellasticity);
}
IPhysicObject po;
bool massflag = false;
if (mi[0].mass == 0)
{
massflag = true;
mi[0].mass = 0.5f;
}
BatchInformation binf = model.GetBatchInformation(0)[0];
BoundingBox bb;
switch (mi[0].collisionType)
{
case "Ghost":
po = new GhostObject(mi[0].position, Matrix.CreateFromQuaternion(mi[0].rotation), mi[0].scale);
break;
case "Cylinder":
binf.ModelLocalTransformation = Matrix.Identity;
bb = ModelBuilderHelper.CreateBoundingBoxFromModel(binf);
Vector3 len = bb.Max - bb.Min;
po = new CylinderObject(mi[0].position, len.Y, len.X / 2, Vector3.Up, mi[0].mass, Matrix.CreateFromQuaternion(mi[0].rotation), material);
break;
case "Sphere":
binf.ModelLocalTransformation = Matrix.Identity;
po = new SphereObject(mi[0].position, model.GetModelRadius(), mi[0].mass, mi[0].scale.X, material);
po.Rotation = Matrix.CreateFromQuaternion(mi[0].rotation);
break;
case "Box":
bb = ModelBuilderHelper.CreateBoundingBoxFromModel(binf);
len = bb.Max - bb.Min;
po = new BoxObject(mi[0].position, len.X, len.Y, len.Z, mi[0].mass, mi[0].scale, Matrix.CreateFromQuaternion(mi[0].rotation), material);
break;
case "Water":
po = new GhostObject(mi[0].position, Matrix.CreateFromQuaternion(mi[0].rotation), mi[0].scale);
break;
case "TriangleMesh":
default:
po = new TriangleMeshObject(model, Vector3.Zero, Matrix.Identity, new Vector3(1), material);
break;
}
po.isMotionLess = massflag;
IShader shader = null;
#if !REACH && !WINDOWS_PHONE
if (mi[0].HasTexture(TextureType.ENVIRONMENT))
{
shader = new DeferredEMReflectiveShader();
(shader as DeferredEMReflectiveShader).TextureCube = mi[0].textureInformation.getCubeTexture(TextureType.ENVIRONMENT);
}
else if (mi[0].collisionType != null && mi[0].collisionType.Contains("Water"))
{
Vector3 position = (Vector3)(mi[0].extra["position"]);
var width = (mi[0].extra["width"]);
var height = (mi[0].extra["length"]);
shader = new DeferredWaterCompleteShader((int)width, (int)height, new Plane(position.X, position.Y, position.Z, 1), 10.0f);
}
else
{
shader = new DeferredCustomShader(mi[0].HasTexture(TextureType.GLOW), mi[0].HasTexture(TextureType.BUMP), mi[0].HasTexture(TextureType.SPECULAR), mi[0].HasTexture(TextureType.PARALAX));
}
DeferredMaterial dm = new DeferredMaterial(shader);
#else
shader = new ForwardXNABasicShader();
ForwardMaterial dm = new ForwardMaterial(shader);
#endif
IObject ob = new IObject(dm, model, po);
ob.Name = mi[0].modelName;
return(new IObject[] { ob });
}
public ModelLoaderData Load(GraphicFactory factory, GraphicInfo ginfo, String Name)
{
ModelLoaderData elements = new ModelLoaderData();
Dictionary <String, XmlModelMeshInfo> infos = new Dictionary <string, XmlModelMeshInfo>();
Dictionary <String, targetInfo> targets = new Dictionary <string, targetInfo>();
Dictionary <String, SpotLightInformation> spotLights = new Dictionary <string, SpotLightInformation>();
//Dictionary<String, ConstraintInformation> constraints = new Dictionary<string, ConstraintInformation>();
Dictionary <String, CameraInfo> cameras = new Dictionary <string, CameraInfo>();
Dictionary <String, ParticleInfo> particles = new Dictionary <string, ParticleInfo>();
SerializerHelper.ChangeDecimalSymbolToPoint();
XmlDocument xDoc = new XmlDocument();
xDoc.Load(path + Name + ".xml");
XmlNodeList worldNode = xDoc["SCENE"].ChildNodes;
foreach (XmlNode node in worldNode)
{
if (node.Name == "Constraint")
{
ConstraintInfo cinfo = new ConstraintInfo();
cinfo.Name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
XmlElement type = node["type"];
if (type != null)
{
cinfo.type = SerializerHelper.DeserializeAttributeBaseType <String>("value", type);
}
XmlElement child = node["child"];
if (child != null)
{
cinfo.bodyA = SerializerHelper.DeserializeAttributeBaseType <String>("name", child);
}
XmlElement parent = node["parent"];
if (parent != null)
{
cinfo.bodyB = SerializerHelper.DeserializeAttributeBaseType <String>("name", parent);
}
XmlElement breakable = node["isBreakable"];
if (breakable != null)
{
cinfo.breakable = SerializerHelper.DeserializeAttributeBaseType <bool>("value", breakable);
}
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
cinfo.Position = new Vector3(pos.X, pos.Y, pos.Z);
elements.ConstraintInfo.Add(cinfo);
}
if (node.Name == "particle")
{
ParticleInfo pinfo = new ParticleInfo();
pinfo.Name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
pinfo.Position = SerializerHelper.DeserializeVector3("position", node);
pinfo.Orientation = SerializerHelper.DeserializeQuaternion("rotation", node);
XmlElement mass = node["type"];
if (mass != null)
{
pinfo.Type = SerializerHelper.DeserializeAttributeBaseType <String>("value", mass);
}
elements.ParticleInfo.Add(pinfo);
}
if (node.Name == "body")
{
XmlModelMeshInfo info = new XmlModelMeshInfo();
info.modelName = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
XmlElement mass = node["mass"];
if (mass != null)
{
info.mass = SerializerHelper.DeserializeAttributeBaseType <float>("value", mass);
}
XmlElement dfric = node["dinamicfriction"];
if (dfric != null)
{
info.dinamicfriction = SerializerHelper.DeserializeAttributeBaseType <float>("value", dfric);
}
XmlElement sfric = node["staticfriction"];
if (sfric != null)
{
info.staticfriction = SerializerHelper.DeserializeAttributeBaseType <float>("value", sfric);
}
XmlElement ellas = node["ellasticity"];
if (ellas != null)
{
info.ellasticity = SerializerHelper.DeserializeAttributeBaseType <float>("value", ellas);
}
XmlElement collision = node["collision"];
if (collision != null)
{
info.collisionType = SerializerHelper.DeserializeAttributeBaseType <String>("type", collision);
if (info.collisionType.Contains("Water"))
{
Vector3 pos = SerializerHelper.DeserializeVector3("position", collision);
float width = SerializerHelper.DeserializeAttributeBaseType <float>("value", collision["width"]);
float length = SerializerHelper.DeserializeAttributeBaseType <float>("value", collision["length"]);
info.material.extrainformation = new Dictionary <string, object>();
info.material.extrainformation.Add("position", pos);
info.material.extrainformation.Add("width", width);
info.material.extrainformation.Add("length", length);
}
}
XmlElement material = node["material"];
if (material == null)
{
info.material.difuseName = "white";
}
else
{
XmlElement reflect = material["reflection"];
if (reflect != null)
{
info.material.reflectionName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", reflect));
}
else
{
XmlElement difuse = material["diffuse"];
if (difuse != null)
{
info.material.difuseName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", difuse));
}
XmlElement bump = material["bump"];
if (bump != null)
{
info.material.bumpName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", bump));
}
XmlElement specular = material["specular"];
if (specular != null)
{
info.material.specularName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", specular));
}
XmlElement glow = material["glow"];
if (glow != null)
{
info.material.glowName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", glow));
}
}
}
infos.Add(info.modelName, info);
}
else if (node.Name == "pointlight")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
Vector3 vColor = SerializerHelper.DeserializeVector3("color", node);
Color color = new Color(vColor.X / 255, vColor.Y / 255, vColor.Z / 255);
float amount = SerializerHelper.DeserializeAttributeBaseType <float>("amount", node["multiplier"]);
float decay = SerializerHelper.DeserializeAttributeBaseType <float>("value", node["decay"]);
PointLightPE pl = new PointLightPE(pos, color, 200, amount);
pl.Name = name;
pl.UsePointLightQuadraticAttenuation = true;
elements.LightsInfo.Add(pl);
}
else if (node.Name == "spotlight")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
Vector3 vColor = SerializerHelper.DeserializeVector3("color", node);
float fallof = SerializerHelper.DeserializeBaseType <float>("fallof", node);
Color color = new Color(vColor.X / 255, vColor.Y / 255, vColor.Z / 255);
float amount = SerializerHelper.DeserializeAttributeBaseType <float>("amount", node["multiplier"]);
float decay = SerializerHelper.DeserializeAttributeBaseType <float>("value", node["decay"]);
bool castShadow = SerializerHelper.DeserializeBaseType <bool>("castShadows", node);
SpotLightInformation spi = new SpotLightInformation();
spi.angle = MathHelper.ToRadians(fallof);
spi.color = color;
spi.decay = decay;
spi.multiplier = amount;
spi.name = name;
spi.pos = pos;
spi.castShadow = castShadow;
spotLights.Add(spi.name, spi);
}
else if (node.Name == "target")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
targetInfo ti = new targetInfo();
ti.targetPos = pos;
ti.name = name;
targets.Add(ti.name, ti);
}
else if (node.Name == "camera")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
CameraInfo co = new CameraInfo();
co.Name = name;
co.Position = pos;
cameras.Add(co.Name, co);
}
else if (node.Name == "dummy")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
DummyInfo di = new DummyInfo();
di.Name = name;
di.Position = pos;
elements.DummyInfo.Add(di);
}
}
///////PROCCESS LIGHTS /////////////////////
foreach (var item in spotLights)
{
SpotLightInformation si = item.Value;
targetInfo ti = targets[item.Key + ".Target"];
SpotLightPE sl = new SpotLightPE(si.pos, Vector3.Normalize(ti.targetPos - si.pos), si.color, si.decay, (ti.targetPos - si.pos).Length() * 10f, (float)Math.Cos(si.angle / 2), si.multiplier);
sl.CastShadown = si.castShadow;
sl.Name = si.name;
elements.LightsInfo.Add(sl);
}
///////PROCCESS CAMERAS/////////////////////
foreach (var item in cameras)
{
CameraInfo ci = item.Value;
targetInfo ti = targets[item.Key + ".Target"];
ci.Target = ti.targetPos;
elements.CameraInfo.Add(ci);
}
Model model = factory.GetModel(modelPath + Name);
modelNames.Add(modelPath + Name);
Matrix[] m = new Matrix[model.Bones.Count];
model.CopyAbsoluteBoneTransformsTo(m);
////////////EXTRAINDO MESHES
for (int i = 0; i < model.Meshes.Count; i++)
{
String name = model.Meshes[i].Name.Substring(5);
if (infos.ContainsKey(name))
{
for (int j = 0; j < model.Meshes[i].MeshParts.Count; j++)
{
XmlModelMeshInfo inf = infos[name];
Matrix tr = m[model.Meshes[i].ParentBone.Index];
Vector3 scale;
Vector3 pos;
Quaternion ori;
tr.Decompose(out scale, out ori, out pos);
ObjectInformation mi = new ObjectInformation();
mi.modelName = inf.modelName;
mi.meshPartIndex = j;
mi.meshIndex = i;
mi.position = pos;
mi.scale = scale;
mi.rotation = ori;
ModelBuilderHelper.Extract(m, model.Meshes[i].MeshParts[j], out mi.batchInformation);
mi.ellasticity = inf.ellasticity;
mi.dinamicfriction = inf.dinamicfriction;
mi.staticfriction = inf.staticfriction;
mi.collisionType = inf.collisionType;
mi.mass = inf.mass;
mi.batchInformation.ModelLocalTransformation = m[model.Meshes[i].ParentBone.Index];
mi.textureInformation = new TextureInformation(false, factory);
if (inf.material.reflectionName != null)
{
mi.textureInformation.SetCubeTexture(factory.GetTextureCube(texturePath + inf.material.reflectionName), TextureType.ENVIRONMENT);
texturesNames.Add(texturePath + inf.material.reflectionName);
}
else
{
if (inf.material.difuseName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.difuseName), TextureType.DIFFUSE);
texturesNames.Add(texturePath + inf.material.difuseName);
}
if (inf.material.glowName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.glowName), TextureType.GLOW);
texturesNames.Add(texturePath + inf.material.glowName);
}
if (inf.material.specularName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.specularName), TextureType.SPECULAR);
texturesNames.Add(texturePath + inf.material.specularName);
}
if (inf.material.bumpName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.bumpName), TextureType.BUMP);
texturesNames.Add(texturePath + inf.material.bumpName);
}
}
if (inf.collisionType != null)
{
if (inf.collisionType.Contains("Water"))
{
mi.extra = inf.material.extrainformation;
}
}
mi.textureInformation.LoadTexture();
elements.ModelMeshesInfo.Add(mi);
}
}
}
SerializerHelper.ChangeDecimalSymbolToSystemDefault();
//Clear Stuffs
infos.Clear();
targets.Clear();
spotLights.Clear();
cameras.Clear();
return(elements);
}
