コード例 #1
0
        public void LoadRawAsset()
        {
            if (this.RawRes != null || !File.Exists(this.AssetPath))
            {
                return;
            }

            switch (this.ResourceType)
            {
            case EResoucresTypes.TextureType:
                RawRes = new TextureAttribute(this);
                break;

            case EResoucresTypes.MatrialType:
                RawRes = new MaterialAttribute(this);
                break;

            case EResoucresTypes.ShaderType:
                RawRes = new ShaderAttribute(this);
                break;

            case EResoucresTypes.MeshType:
                RawRes = new MeshAttribute(this);
                break;
            }
        }
コード例 #2
0
        public async Task <ActionResult> Save(MaterialAttributeViewModel model)
        {
            using (MaterialAttributeServiceClient client = new MaterialAttributeServiceClient())
            {
                MaterialAttribute obj = new MaterialAttribute()
                {
                    Key = new MaterialAttributeKey()
                    {
                        MaterialCode  = model.MaterialCode,
                        AttributeName = model.AttributeName
                    },
                    Value    = model.Value,
                    Editor   = User.Identity.Name,
                    EditTime = DateTime.Now,
                };
                MethodReturnResult rst = await client.AddAsync(obj);

                if (rst.Code == 0)
                {
                    rst.Message = string.Format(FMMResources.StringResource.MaterialAttribute_Save_Success
                                                , obj.Key);
                }
                return(Json(rst));
            }
        }
コード例 #3
0
        public bool UpdateMaterialAttributes(List <MaterialAttribute> lMaterialAttributes)
        {
            bool isUpdate = true;

            try
            {
                foreach (MaterialAttribute itemMaterialAttribute in lMaterialAttributes)
                {
                    var materialAttributes = jmdc.MaterialAttributes.Where(p => p.MaterialId == itemMaterialAttribute.MaterialId && p.AttributeId == itemMaterialAttribute.AttributeId).Select(p => p);
                    if (materialAttributes.Any() == false)
                    {
                        jmdc.MaterialAttributes.InsertOnSubmit(itemMaterialAttribute);
                        jmdc.SubmitChanges();
                    }
                    else
                    {
                        MaterialAttribute selectedMaterialAttribute = materialAttributes.FirstOrDefault();
                        selectedMaterialAttribute.MaterialId  = itemMaterialAttribute.MaterialId;
                        selectedMaterialAttribute.AttributeId = itemMaterialAttribute.AttributeId;
                        selectedMaterialAttribute.SortOder    = itemMaterialAttribute.SortOder;
                        selectedMaterialAttribute.IsRequired  = itemMaterialAttribute.IsRequired;
                        jmdc.SubmitChanges();
                    }
                }
            }
            catch (Exception)
            {
                isUpdate = false;
                return(isUpdate);
            }

            return(isUpdate);
        }
コード例 #4
0
        void cb_Click(object sender, RoutedEventArgs e)
        {
            CheckBox          cb = ((CheckBox)sender);
            MaterialAttribute r  = (MaterialAttribute)Enum.Parse(typeof(MaterialAttribute), cb.Name);

            if (objectToEdit != null && objectToEdit is Material)
            {
                ((Material)objectToEdit).setAttribute(r, cb.IsChecked.HasValue && cb.IsChecked.Value);
            }
        }
コード例 #5
0
 public RayTracingObject()
 {
     o_type     = ObjectType.none;
     l_type     = LightType.none;
     m_type     = MaterialType.none;
     pos        = Vector3.zero;
     rot        = Vector3.zero;
     scale      = Vector3.one;
     whrInfo    = Vector3.zero;
     yminmax    = Vector2.zero;
     mattr      = new MaterialAttribute();
     lightColor = Vector3.zero;
     nsample    = 0;
 }
コード例 #6
0
        public JsonResult UpdateAttribute([FromBody] MaterialAttribute obj)
        {
            var msg = new JMessage {
                Title = "", Error = false
            };

            try
            {
                _context.MaterialAttributes.Update(obj);
                _context.SaveChanges();
                msg.Title = String.Format(CommonUtil.ResourceValue("COM_MSG_UPDATE_SUCCESS"), CommonUtil.ResourceValue("MLP_MSG_PROPETIES_ADD"));
            }
            catch
            {
                msg.Error = true;
                msg.Title = String.Format(CommonUtil.ResourceValue("COM_MSG_UPDATE_FAILED"), CommonUtil.ResourceValue("MLP_MSG_PROPETIES_ADD"));
            }
            return(Json(msg));
        }
コード例 #7
0
        private void WriteMaterialAttribute(uint version, MaterialAttribute attribute)
        {
            WriteUInt(attribute.RawFlags);

            switch (attribute.Type)
            {
            case MaterialAttributeType.Type0:
                WriteMaterialAttributeType0(version, ( MaterialAttributeType0 )attribute);
                break;

            case MaterialAttributeType.Type1:
                WriteMaterialAttributeType1(version, ( MaterialAttributeType1 )attribute);
                break;

            case MaterialAttributeType.Type2:
                WriteMaterialAttributeType2(( MaterialAttributeType2 )attribute);
                break;

            case MaterialAttributeType.Type3:
                WriteMaterialAttributeType3(( MaterialAttributeType3 )attribute);
                break;

            case MaterialAttributeType.Type4:
                WriteMaterialAttributeType4(( MaterialAttributeType4 )attribute);
                break;

            case MaterialAttributeType.Type5:
                WriteMaterialAttributeType5(( MaterialAttributeType5 )attribute);
                break;

            case MaterialAttributeType.Type6:
                WriteMaterialAttributeType6(( MaterialAttributeType6 )attribute);
                break;

            case MaterialAttributeType.Type7:
                // no data
                break;

            default:
                throw new Exception($"Unknown material attribute type { attribute.Type } ");
            }
        }
コード例 #8
0
        public bool DeleteAttributeFromMaterial(int MaterialId, int AttributeId)
        {
            bool isResult = true;

            try
            {
                MaterialAttribute objMaterialAttribute = jmdc.MaterialAttributes.Where(p => p.MaterialId == MaterialId && p.AttributeId == AttributeId).Select(p => p).FirstOrDefault();
                if (objMaterialAttribute != null)
                {
                    jmdc.MaterialAttributes.DeleteOnSubmit(objMaterialAttribute);
                    jmdc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                isResult = false;
                throw;
            }
            return(isResult);
        }
コード例 #9
0
        private void bSave_Click(object sender, RoutedEventArgs e)
        {
            int iMaterialId = Convert.ToInt32(dMaterials.SelectedValue);

            if (iMaterialId != 0)
            {
                Material objSelectedMaterial = new Material();
                objSelectedMaterial.Id       = Convert.ToInt32(dMaterials.SelectedValue);
                objSelectedMaterial.Name     = dMaterials.Text;
                objSelectedMaterial.TypeId   = Convert.ToInt32(dMaterialType.SelectedValue);
                objSelectedMaterial.IsActive = Convert.ToBoolean(cIsEnable.IsChecked);

                List <MaterialGridAttribute> objSelectedMaterialGridAttribute = (List <MaterialGridAttribute>)dSelectedAttributes.ItemsSource;
                List <MaterialAttribute>     lSelectedMaterialAttributes      = new List <MaterialAttribute>();
                for (int i = 1; i <= objSelectedMaterialGridAttribute.Count(); i++)
                {
                    MaterialAttribute objMaterialAttribute = new MaterialAttribute();
                    objMaterialAttribute.MaterialId  = objSelectedMaterial.Id;
                    objMaterialAttribute.AttributeId = objSelectedMaterialGridAttribute[i - 1].Attribute.AttributeId;
                    objMaterialAttribute.SortOder    = i;
                    objMaterialAttribute.IsRequired  = true;
                    lSelectedMaterialAttributes.Add(objMaterialAttribute);
                }

                bool isMaterialUpdate = objDataAccess.UpdateMaterial(objSelectedMaterial);
                if (isMaterialUpdate)
                {
                    bool isMaterialAttributeUpdate = objDataAccess.UpdateMaterialAttributes(lSelectedMaterialAttributes);
                    if (isMaterialAttributeUpdate)
                    {
                        MessageBox.Show("Material Saved successfully");
                    }
                }
                else
                {
                    MessageBox.Show("Material Failed to Save");
                }
                // For existing material save
            }
            else
            {
                // For New Material save
                Material objNewMaterial = new Material();
                objNewMaterial.Name     = dMaterials.Text;
                objNewMaterial.IsActive = Convert.ToBoolean(cIsEnable.IsChecked);
                objNewMaterial.TypeId   = Convert.ToInt32(dMaterialType.SelectedValue);
                bool isSuccesss = objDataAccess.AddMaterial(objNewMaterial);

                List <MaterialGridAttribute> objSelectedMaterialGridAttribute = (List <MaterialGridAttribute>)dSelectedAttributes.ItemsSource;
                if (objSelectedMaterialGridAttribute != null)
                {
                    List <MaterialAttribute> lSelectedMaterialAttributes = new List <MaterialAttribute>();
                    for (int i = 1; i <= objSelectedMaterialGridAttribute.Count(); i++)
                    {
                        MaterialAttribute objMaterialAttribute = new MaterialAttribute();
                        objMaterialAttribute.MaterialId  = objNewMaterial.Id;
                        objMaterialAttribute.AttributeId = objSelectedMaterialGridAttribute[i - 1].Attribute.AttributeId;
                        objMaterialAttribute.SortOder    = i;
                        objMaterialAttribute.IsRequired  = true;
                        lSelectedMaterialAttributes.Add(objMaterialAttribute);
                    }
                    if (isSuccesss)
                    {
                        bool isMaterialAttributeUpdate = objDataAccess.UpdateMaterialAttributes(lSelectedMaterialAttributes);
                        if (isMaterialAttributeUpdate)
                        {
                            MessageBox.Show("Material Saved successfully");
                        }
                    }
                    else
                    {
                        MessageBox.Show("Material Failed to Save");
                    }
                }
                else
                {
                    MessageBox.Show("Material cannot be saved without selecting selected attribute");
                }
            }
            ClearScreen();
        }
コード例 #10
0
 protected override void InitializeCore()
 {
     RegisterExportHandler <Stream>(path => MaterialAttribute.Save(Data, path));
     RegisterReplaceHandler <Stream>(Resource.Load <MaterialAttributeType7>);
 }
コード例 #11
0
        private void btnOk_Click(object sender, RoutedEventArgs e)
        {
            if (objectToEdit == null)
            {
                objectToEdit = new Material();
            }

            Material obj = objectToEdit as Material;

            obj.BaseObjectId   = txtBaseObjectId.Text;
            obj.BaseObjectName = txtBaseObjectName.Text;
            obj.MaterialIndex  = int.Parse(txtMaterialIndex.Text);

            //custom code
            obj.Emissive             = (float)Emissive.Value;
            obj.Reflectivity         = (float)Reflectivity.Value;
            obj.ReflectionSmoothness = (float)ReflectionSmoothness.Value;
            obj.SpecularIntensity    = (float)specularIntensity.Value;
            obj.SpecularPower        = (int)specularPower.Value;

            obj.Roughness          = (float)roughness.Value;
            obj.RefAtNormIncidence = (float)refAtNormIncidence.Value;
            obj.Smoothness         = (float)smoothness.Value;
            obj.Metalness          = (float)metalness.Value;

            obj.AnisotropicRoughnessX = (float)anisotropicRoughnessX.Value;
            obj.AnisotropicRoughnessY = (float)anisotropicRoughnessY.Value;

            if (ddlLightingModel.SelectedItem != null)
            {
                obj.LightModel = (LightingModel)Enum.Parse(typeof(LightingModel), ((ComboBoxItem)ddlLightingModel.SelectedItem).Name);
            }

            foreach (CheckBox cb in divAttributes.Children)
            {
                MaterialAttribute r = (MaterialAttribute)Enum.Parse(typeof(MaterialAttribute), cb.Name);
                obj.setAttribute(r, cb.IsChecked.HasValue && cb.IsChecked.Value);
            }

            String cubTexName = cubeMapToLoad.Content != null?cubeMapToLoad.Content.ToString() : "";

            if (string.IsNullOrEmpty(cubTexName))
            {
                obj.CubeMapSRV         = null;
                obj.CubeMapTextureName = null;
            }
            else
            {
                obj.CubeMapSRV         = TextureLoader.LoadCubeTexture("fx/" + cubTexName);
                obj.CubeMapTextureName = cubTexName;
            }

            String detailTexName = detailMapToLoad.Content != null?detailMapToLoad.Content.ToString() : "";

            if (string.IsNullOrEmpty(detailTexName))
            {
                obj.DetailMapSRV         = null;
                obj.DetailMapTextureName = null;
            }
            else
            {
                obj.DetailMapSRV         = TextureLoader.LoadTexture("detail/" + detailTexName);
                obj.DetailMapTextureName = detailTexName;
            }



            //custom code end

            obj.Category = objCategory;
            bool success = isEditingObj ? WorldData.UpdateObject(obj) : WorldData.AddObject(obj);

            if (!success)
            {
                MessageBox.Show(Application.Current.MainWindow, "ID already exists", "AddObject Failure", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.Cancel);
            }
            else
            {
                this.Close();
                if (parentWindow != null)
                {
                    parentWindow.Refresh();
                }
            }
        }
コード例 #12
0
ファイル: Material.cs プロジェクト: RomanSery/weather-engine
 public void setAttribute(MaterialAttribute r, bool val)
 {
     initAttributes();
     attributes[r] = val;
 }
コード例 #13
0
ファイル: Material.cs プロジェクト: RomanSery/weather-engine
 public bool getAttribute(MaterialAttribute r)
 {
     initAttributes();
     return(attributes.ContainsKey(r) ? attributes[r] : false);
 }
コード例 #14
0
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // constructors                                                                                                     //
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        /// <summary>Creates a new instance of this class.</summary>
        /// <param name="t">Type.</param>
        public __Entity(Type t)
        {
            EntityAttribute tattr = (EntityAttribute)t.GetCustomAttribute(typeof(EntityAttribute));

            if (tattr == null)
            {
                MaterialAttribute mattr = (MaterialAttribute)t.GetCustomAttribute(typeof(MaterialAttribute));
                if (mattr != null)
                {
                    TableName   = mattr.TableName;
                    SubsetQuery = mattr.SubsetQuery;
                    IsMaterial  = true;
                }
            }
            else
            {
                TableName   = tattr.TableName;
                SubsetQuery = tattr.SubsetQuery;
                ChildKey    = tattr.ChildKey;
            }

            if (string.IsNullOrWhiteSpace(TableName))
            {
                TableName = t.Name.ToUpper();
            }

            Member = t;
            List <__Field> fields = new List <__Field>();

            foreach (PropertyInfo i in t.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                if ((IgnoreAttribute)i.GetCustomAttribute(typeof(IgnoreAttribute)) != null)
                {
                    continue;
                }

                __Field field = new __Field(this);

                FieldAttribute fattr = (FieldAttribute)i.GetCustomAttribute(typeof(FieldAttribute));

                if (fattr != null)
                {
                    if (fattr is PrimaryKeyAttribute)
                    {
                        PrimaryKey         = field;
                        field.IsPrimaryKey = true;
                    }

                    field.ColumnName = (fattr?.ColumnName ?? i.Name);
                    field.ColumnType = (fattr?.ColumnType ?? i.PropertyType);

                    field.IsNullable = fattr.Nullable;

                    if (field.IsForeignKey = (fattr is ForeignKeyAttribute))
                    {
                        field.IsExternal = typeof(IEnumerable).IsAssignableFrom(i.PropertyType);

                        field.AssignmentTable  = ((ForeignKeyAttribute)fattr).AssignmentTable;
                        field.RemoteColumnName = ((ForeignKeyAttribute)fattr).RemoteColumnName;
                        field.IsManyToMany     = (!string.IsNullOrWhiteSpace(field.AssignmentTable));
                    }
                }
                else
                {
                    if ((i.GetGetMethod() == null) || (!i.GetGetMethod().IsPublic))
                    {
                        continue;
                    }

                    field.ColumnName = i.Name;
                    field.ColumnType = i.PropertyType;
                }
                field.Member = i;

                fields.Add(field);
            }

            Fields    = fields.ToArray();
            Internals = fields.Where(m => (!m.IsExternal)).ToArray();
            Externals = fields.Where(m => m.IsExternal).ToArray();
        }