void view_Refresh(object sender, EventArgs e)
{
//(sender as TypeSetupControl).Controls[1].Enabled = false;
//if (???)
//{
// (sender as TypeSetupControl).Controls[1].Enabled = false;
//}
//else
//{
// (sender as TypeSetupControl).Controls[1].Enabled = true;
//}
if (view.CurrentItem != null)
{
current = view.CurrentItem;
}
model.Reload();
if (model.ItemList.Select(n => n.Id).Contains(current.Id))
{
view.CurrentItem = model.ItemList.First(n => n.Id == current.Id);
}
else
{
view.CurrentItem = model.ItemList.First(n => n.Id == model.ItemList.Last().Id);
}
}
public void EditorThread_SetPreviewMeshMaterial(CMaterial material)
{
OnEngineThread(() =>
{
m_previewMesh?.SetMaterialOverride(material);
});
}
public void InitDefaultResources(DeviceContext deviceContext)
{
DefaultShader = RequestShaderResource(new SHashedName("SimpleLitShader"));
DepthShader = RequestShaderResource(new SHashedName("depthShader"));
DepthCubeShader = RequestShaderResource(new SHashedName("depthCubeShader"));
DefaultTexture = new CTextureSampler(m_graphicsDevice, deviceContext, "Resources/Textures/DefaultTexture.tga");
FallbackTexture = new CTextureSampler(m_graphicsDevice, deviceContext, "Resources/Textures/MissingTexture.tga");
WhiteTexture = new CTextureSampler(m_graphicsDevice, deviceContext, "Resources/Textures/DefaultWhite.tga");
BlackTexture = new CTextureSampler(m_graphicsDevice, deviceContext, "Resources/Textures/DefaultBlack.tga");
DefaultMaterial = CMaterial.CreateDefaultMaterial();
DefaultMaterial.ShaderResource = DefaultShader;
DefaultMaterial.SetTextureParameter(new SHashedName("DiffuseTexture"), WhiteTexture);
DefaultMaterial.FinishLoading();
DefaultTextureMaterial = CMaterial.CreateDefaultMaterial();
DefaultTextureMaterial.ShaderResource = DefaultShader;
DefaultTextureMaterial.SetTextureParameter(new SHashedName("DiffuseTexture"), DefaultTexture);
DefaultTextureMaterial.FinishLoading();
MissingTextureMaterial = CMaterial.CreateDefaultMaterial();
MissingTextureMaterial.ShaderResource = DefaultShader;
MissingTextureMaterial.SetTextureParameter(new SHashedName("DiffuseTexture"), FallbackTexture);
MissingTextureMaterial.FinishLoading();
}
public CollisionEndEventArgs(IntPtr materialPtr, IntPtr contactPoint, CMaterial material1, CMaterial material2)
{
_materialPtr = materialPtr;
_contactPoint = contactPoint;
_material1 = material1;
_material2 = material2;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Выбор шаблона привязки данных
/// </summary>
/// <param name="item">Объект</param>
/// <param name="container">Контейнер</param>
/// <returns>Нужный шаблон</returns>
//---------------------------------------------------------------------------------------------------------
public override DataTemplate SelectTemplate(Object item, DependencyObject container)
{
CScene3D scene = item as CScene3D;
if (scene != null)
{
return(Scene);
}
CNode3D node = item as CNode3D;
if (node != null)
{
return(Node);
}
CModel3D model = item as CModel3D;
if (model != null)
{
return(Model);
}
CMesh3Df mesh = item as CMesh3Df;
if (mesh != null)
{
return(Mesh);
}
CMeshSet mesh_set = item as CMeshSet;
if (mesh_set != null)
{
return(MeshSet);
}
CMaterial material = item as CMaterial;
if (material != null)
{
return(Material);
}
CTextureSlot texture_slot = item as CTextureSlot;
if (texture_slot != null)
{
return(TextureSlot);
}
CMaterialSet material_set = item as CMaterialSet;
if (material_set != null)
{
return(MaterialSet);
}
return(Scene);
}
public JsonResult saveMaterial(CMaterial model)
{
string message = "";
string ErrMessage = "";
int ErrCode = 0;
int materialId = 0;
if (Session["ident"] == null)
{
message = "identError";
}
if (message == "")
{
string ident = Session["ident"].ToString();
SmManager.gMaterialCL material = new SmManager.gMaterialCL();
material.materialId = model.materialId;
material.material = model.material;
material.materialShort = model.materialShort;
SmManager.SmManagerClient cl = new SmManager.SmManagerClient();
material = cl.saveMaterial(ident, material);
ErrMessage = material.ErrMessage;
ErrCode = material.ErrCode;
materialId = material.materialId;
}
return(Json(new
{
message = message,
errMessage = ErrMessage,
errCode = ErrCode.ToString(),
materialId = materialId
}, JsonRequestBehavior.AllowGet));
}
public override void Update()
{
float y = Math.Min(1, _vehicle.Chassis.Actor.AngularVelocity.Y / 10);
Speed.X = y;
Speed.Y = Math.Min(1, _vehicle.Chassis.Actor.LinearVelocity.Length() / 10);
_uvOffset += Speed * Engine.ElapsedSeconds;
if (_uvOffset.X > 10)
{
_uvOffset.X = 10 - _uvOffset.X;
}
if (_uvOffset.Y > 10)
{
_uvOffset.Y = 10 - _uvOffset.Y;
}
if (_vehicle.CurrentSpecialVolume.Count > 0)
{
SpecialVolume vol = _vehicle.CurrentSpecialVolume.Peek();
CMaterial mat = ResourceCache.GetMaterial(vol.WindscreenMaterial);
if (mat != null)
{
this.Material.Texture = mat.Texture;
}
}
else
{
this.Material.Texture = _origTexture;
}
}
public void removeItemFromList(int matType)
{
CMaterial found = materials.Find(x => x.getMaterialType() == matType);
if (found != null)
{
materials.Remove(found);
}
}
public void SetMaterial(int materialIndex, CMaterial material)
{
m_overrideMaterials.SetMinSize(materialIndex + 1);
m_overrideMaterials[materialIndex] = material;
if (m_renderNodes.Length < materialIndex)
{
m_renderNodes[materialIndex].SetMaterialOverride(material);
}
}
public virtual void Resolve()
{
CMaterial cm = ResourceCache.GetMaterial(MaterialName);
if (cm == null)
{
return;
}
cm.Funk = this;
Material = cm;
}
public void AddMaterialToHands(CMaterial mat, int i)
{
if (i == 0)
{
mat.transform.parent = hands.transform.Find("FirstItem").transform;
}
if (i == 1)
{
mat.transform.parent = hands.transform.Find("SecondItem").transform;
}
mat.transform.localPosition = Vector3.zero;
}
public void takeMaterial()
{
// Cargar un material dependiendo del tipo, ej se agarra bandera se carga tela a la lista
AudioManager.Inst.Play("agarrar_item");
GameObject matObject = Instantiate <GameObject>(materialTemplate, GameController.Inst.player.transform);
//Debug.Log(matObject);
CMaterial mat = matObject.GetComponent <CMaterial>();
mat.setMaterialType(type);
GameController.Inst.PushMaterials(mat);
//Destroy(this.gameObject);
}
void view_Delete(object sender, EventArgs e)
{
model.Delete(view.CurrentItem);
model.ItemList.Remove(view.CurrentItem);
//model.Reload();
if (view.CurrentItem != null)
{
if (model.ItemList.First() != view.CurrentItem)
{
view.CurrentItem = model.ItemList.First(n => n.Id == model.ItemList.FirstOrDefault().Id);
}
else
{
view.CurrentItem = model.ItemList[0];
}
current = view.CurrentItem;
}
}
public void EngineThread_SetPreviewMesh(CMeshAsset meshAsset, bool bKeepMaterial, bool bZoomToFit)
{
m_currentMeshAsset = meshAsset;
CMaterial nodeMaterial = m_previewMesh?.GetOverrideMaterial();
if (m_previewMesh != null)
{
m_renderScene?.UnregisterRenderNode(m_previewMesh);
}
m_previewMesh = new CMeshRenderNode(null, meshAsset, null, m_previewMeshTransform);
if (bKeepMaterial)
{
m_previewMesh.SetMaterialOverride(nodeMaterial);
}
m_renderScene?.RegisterRenderNode(m_previewMesh);
if (bZoomToFit)
{
EngineThread_ZoomCameraToFitAsset();
}
}
public ActionResult selectMaterial(int materialId)
{
string errorTxt = "";
if (Session["ident"] == null)
{
RedirectToAction("Login", "Home");
}
string ident = Session["ident"].ToString();
CMaterial model = new CMaterial();
if (materialId > 0)
{
SmManager.SmManagerClient cl = new SmManager.SmManagerClient();
SmManager.gMaterialCL[] material = cl.getMaterial(ident, materialId);
if (material.Length == 1)
{
if (material[0].ErrCode != 0)
{
errorTxt = material[0].ErrMessage;
}
else
{
model.materialId = material[0].materialId;
model.material = material[0].material;
model.materialShort = material[0].materialShort;
}
}
else
{
errorTxt = "Kan ej hitta valt material";
}
}
ViewBag.errorTxt = errorTxt;
return(View(model));
}
public bool findMaterial(int matType)
{
CMaterial found = materials.Find(x => x.getMaterialType() == matType);
return(found != null);
}
public MatFile(string filename)
{
Stream file = OpenDataFile(filename);
if (!Exists)
{
return;
}
EndianBinaryReader reader = new EndianBinaryReader(EndianBitConverter.Big, file);
CMaterial currentMaterial = null;
while (true)
{
int blockLength = 0;
MaterialBlockType blockType = (MaterialBlockType)reader.ReadInt32();
blockLength = reader.ReadInt32();
byte[] flags;
switch (blockType)
{
case MaterialBlockType.Attributes:
currentMaterial = new CMaterial();
_materials.Add(currentMaterial);
byte[] color = reader.ReadBytes(4);
byte[] otherColors = reader.ReadBytes(16);
flags = reader.ReadBytes(2);
byte[] transform = reader.ReadBytes(24);
currentMaterial.SimpMatPixelIndex = reader.ReadByte();
currentMaterial.SimpMatGradientCount = reader.ReadByte();
currentMaterial.DoubleSided = flags[0] == 0x10;
currentMaterial.Name = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.AttributesV2:
currentMaterial = new CMaterial();
_materials.Add(currentMaterial);
reader.ReadBytes(4); //color
reader.ReadBytes(16); //othercolors
flags = reader.ReadBytes(4); // flags
reader.ReadBytes(24); //transform
reader.ReadBytes(4); //unk
currentMaterial.DoubleSided = flags[0] == 0x10;
reader.BaseStream.Position += 13;
currentMaterial.Name = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.TextureName:
currentMaterial.PixName = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.TabName:
string tabName = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.Null:
break;
default:
reader.Seek(blockLength, SeekOrigin.Current);
break;
}
if (reader.BaseStream.Position == reader.BaseStream.Length)
{
break;
}
}
reader.Close();
}
public VehicleBitsParticleSystem(CMaterial material)
{
_material = material;
InitializeSystem();
}
/// <summary>
/// Returns a list of all registered materials
/// </summary>
/// <param name="ident"></param>
/// <returns></returns>
/// 2018-08-15 KJBO
public List <gMaterialCL> getAllMaterial(string ident)
{
CMaterial cm = new CMaterial();
return(cm.getAllMaterial(ident));
}
public VehicleBitsParticleSystem(CMaterial material)
{
_material = material;
InitializeSystem();
}
private void view_Add(object sender, EventArgs e)
{
model.Add();
view.CurrentItem = model.ItemList.First(n => n == model.ItemList.LastOrDefault());
current = view.CurrentItem;
}
/// <summary>
/// Returns a list of all registered materials
/// If materialId <> 0 then only the material ID that
/// matches the current ID will be returned.
/// In that case this will be 0 or 1 instance of gMaterialCL
/// </summary>
/// <param name="ident"></param>
/// <returns></returns>
/// 2018-08-15 KJBO
public List <gMaterialCL> getMaterial(string ident, int materialId)
{
CMaterial cm = new CMaterial();
return(cm.getMaterial(ident, materialId));
}
public void Render(CModel model, CCamera cam, CShaderSystem shader, bool transparent)
{
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.AlphaTest);
GL.Enable(EnableCap.DepthTest);
if (model == null)
{
return;
}
CMesh mesh = model.Mesh;
if (mesh.BindVBOs() == false)
{
return;
}
// start shader
if (shader.UseProgram(SupportShader.Model) == true)
{
UniformModel(model);
foreach (CSubset subset in mesh.Subsets)
{
CMaterial material = null;
if (model.Materials.Count > 0 && model.Materials.ContainsKey(subset.Name))
{
material = model.Materials[subset.Name];
}
if (material == null)
{
if (transparent == true) // 재질이 없으면 불투명할 대만 그린다.
{
continue;
}
// Material Routine Func Uniform
int func_index = (int)FSMaterialRoutine.funcBasic;
GL.UniformSubroutines(ShaderType.FragmentShader, 1, ref func_index);
}
else
{
if (transparent != material.IsTransparent())
{
continue;
}
material.GLModeSetting();
material.Bind();
material.Uniform();
}
// Draw
int offset = subset.IndexOffset * sizeof(uint);
int elementCount = subset.TriangleCount * 3;
GL.DrawElements(PrimitiveType.Triangles, elementCount,
DrawElementsType.UnsignedInt, offset);
}
}
shader.ReleaseProgram();
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.Disable(EnableCap.Blend);
mesh.UnbindVBOs();
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.AlphaTest);
GL.Disable(EnableCap.DepthTest);
}
public void Error(CMaterial obj)
{
_log.Error(string.Format("There is no subscribers!/n MaterialID:{0}/n MaterialName:{1}", obj.Id, obj.Name));
}
public void SetMaterial(CMaterial material)
{
m_overrideMaterial = material;
m_renderNode?.SetMaterialOverride(material);
}
public MatFile(string filename)
{
Stream file = OpenDataFile(filename);
if (!Exists)
return;
EndianBinaryReader reader = new EndianBinaryReader(EndianBitConverter.Big, file);
CMaterial currentMaterial = null;
while (true)
{
int blockLength = 0;
MaterialBlockType blockType = (MaterialBlockType)reader.ReadInt32();
blockLength = reader.ReadInt32();
byte[] flags;
switch (blockType)
{
case MaterialBlockType.Attributes:
currentMaterial = new CMaterial();
_materials.Add(currentMaterial);
byte[] color = reader.ReadBytes(4);
byte[] otherColors = reader.ReadBytes(16);
flags = reader.ReadBytes(2);
byte[] transform = reader.ReadBytes(24);
currentMaterial.SimpMatPixelIndex = reader.ReadByte();
currentMaterial.SimpMatGradientCount = reader.ReadByte();
currentMaterial.DoubleSided = flags[0] == 0x10;
currentMaterial.Name = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.AttributesV2:
currentMaterial = new CMaterial();
_materials.Add(currentMaterial);
reader.ReadBytes(4); //color
reader.ReadBytes(16); //othercolors
flags = reader.ReadBytes(4); // flags
reader.ReadBytes(24); //transform
reader.ReadBytes(4); //unk
currentMaterial.DoubleSided = flags[0] == 0x10;
reader.BaseStream.Position += 13;
currentMaterial.Name = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.TextureName:
currentMaterial.PixName = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.TabName:
string tabName = ReadNullTerminatedString(reader);
break;
case MaterialBlockType.Null:
break;
default:
reader.Seek(blockLength, SeekOrigin.Current);
break;
}
if (reader.BaseStream.Position == reader.BaseStream.Length)
break;
}
reader.Close();
}
/// <summary>
/// Saves material to database
/// </summary>
/// <param name="ident"></param>
/// <param name="mat"></param>
/// <returns>The saved material</returns>
/// 2018-08-15 KJBO
public gMaterialCL saveMaterial(string ident, gMaterialCL mat)
{
CMaterial cm = new CMaterial();
return(cm.saveMaterial(ident, mat));
}
public void PushMaterials(CMaterial material)
{
player.AddMaterialToHands(material, materials.Count);
materials.Add(material);
//Debug.Log("Agregado con exito");
}
public void EngineThread_SetPreviewMeshMaterial(CMaterial material)
{
m_previewMesh?.SetMaterialOverride(material);
}
