示例#1
0
        public BaseMaterial GetMaterialLink(int id, BaseDocument doc)
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.BaseContainer_GetMaterialLink(swigCPtr, id, BaseDocument.getCPtr(doc));
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            return(ret);
        }
示例#2
0
 internal RWMaterialProp(String name, BaseMaterial mat, Boolean useCache)
 {
     this.useCache = useCache;
     this.mat      = mat;
     this.propName = name;
     this.cached   = this.useCache ? this.mat.GetProperty <T>(name) : default;
 }
示例#3
0
        public BaseMaterial GetMaterial()
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.TextureTag_GetMaterial__SWIG_1(swigCPtr);
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            return(ret);
        }
 public ProduceMaterialOrder(int idPlayer, Building building)
 {
     this.idPlayer     = idPlayer;
     this.building     = building;
     this.baseMaterial = building.producedMaterial;
     this.timeCounter  = 0;
 }
 protected TriangleElement(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     _material    = (BaseMaterial)info.GetValue("_material", typeof(BaseMaterial));
     _section     = (Base2DSection)info.GetValue("_section", typeof(Base2DSection));
     _behavior    = (TriangleElementBehaviour)info.GetInt32("_behavior");
     _formulation = (MembraneFormulation)info.GetInt32("_behavior");
 }
示例#6
0
        public new static BaseMaterial Alloc(int type)
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.BaseMaterial_Alloc(type);
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            return(ret);
        }
示例#7
0
 /// <summary>
 /// Create an YnMeshModel with an YnModel and a material.
 /// </summary>
 /// <param name="model">An YnModel instance</param>
 /// <param name="material">A material</param>
 public YnMeshModel(string modelName, BaseMaterial material)
     : this()
 {
     _model     = null;
     _modelName = modelName;
     _material  = material;
 }
示例#8
0
 /// <summary>
 /// Create an YnMeshModel with a model loaded from content manager and a material.
 /// </summary>
 /// <param name="model">A Model instance</param>
 /// <param name="material">A material</param>
 public YnMeshModel(Model model, BaseMaterial material)
     : this()
 {
     _model     = model;
     _material  = material;
     _modelName = _model.ToString();
 }
示例#9
0
        public BaseMaterial GetActiveMaterial()
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.BaseDocument_GetActiveMaterial(swigCPtr);
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            return(ret);
        }
示例#10
0
        void SetCustomGpuParameter(VegetationGpuParameters parameter, Vec4 value)
        {
            for (int nMaterial = 0; nMaterial < 4; nMaterial++)
            {
                Material material = null;

                switch (nMaterial)
                {
                case 0:
                    material = BaseMaterial;
                    break;

                case 1:
                    material = BaseMaterial.GetShadowTextureCasterMaterial(RenderLightType.Point);
                    break;

                case 2:
                    material = BaseMaterial.GetShadowTextureCasterMaterial(RenderLightType.Directional);
                    break;

                case 3:
                    material = BaseMaterial.GetShadowTextureCasterMaterial(RenderLightType.Spot);
                    break;
                }

                if (material == null)
                {
                    continue;
                }

                foreach (Technique technique in material.Techniques)
                {
                    foreach (Pass pass in technique.Passes)
                    {
                        if (pass.VertexProgramParameters != null || pass.FragmentProgramParameters != null)
                        {
                            if (pass.VertexProgramParameters != null)
                            {
                                if (!pass.IsCustomGpuParameterInitialized((int)parameter))
                                {
                                    pass.VertexProgramParameters.SetNamedAutoConstant(parameter.ToString(),
                                                                                      GpuProgramParameters.AutoConstantType.Custom, (int)parameter);
                                }
                            }

                            if (pass.FragmentProgramParameters != null)
                            {
                                if (!pass.IsCustomGpuParameterInitialized((int)parameter))
                                {
                                    pass.FragmentProgramParameters.SetNamedAutoConstant(parameter.ToString(),
                                                                                        GpuProgramParameters.AutoConstantType.Custom, (int)parameter);
                                }
                            }

                            pass.SetCustomGpuParameter((int)parameter, value);
                        }
                    }
                }
            }
        }
示例#11
0
        /// <summary>
        /// Gets material used by the model.
        /// </summary>
        /// <returns>An array of material used by the model.</returns>
        public BaseMaterial[] GetModelMaterial()
        {
            List <BaseMaterial> materials = new List <BaseMaterial>();
            BaseMaterial        material  = null;

            foreach (ModelMesh mesh in _model.Meshes)
            {
                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    material = new BasicMaterial();

                    var effect = part.Effect as BasicEffect;

                    if (effect != null)
                    {
                        material.Texture = effect.Texture;
                        material.Effect  = effect;
                    }

                    materials.Add(material);
                }
            }

            return(materials.ToArray());
        }
        public static int InsertBaseMaterial(BaseMaterial bm)
        {
            int isInsert = 0;

            try
            {
                string        query   = SQLClass.INSERT_INTO_BASEMATERIAL;
                NpgsqlCommand command = new NpgsqlCommand(query);
                command.CommandType = CommandType.Text;
                command.Parameters.Add("matcode", bm.Matcode);
                command.Parameters.Add("description", bm.Description);
                command.Parameters.Add("orderdescription", bm.OrderDescription);
                command.Parameters.Add("suppcode", bm.SuppCode);
                command.Parameters.Add("prjcode", bm.PrjCode);
                command.Parameters.Add("edmcode", bm.EdmCode);
                command.Parameters.Add("unit", bm.Unit);
                command.Parameters.Add("packunit", bm.PackUnit);
                command.Parameters.Add("purchaseprice", bm.PurchasePrice);
                command.Parameters.Add("discount1", bm.Discount1);
                command.Parameters.Add("discount2", bm.Discount2);
                command.Parameters.Add("freight", bm.Freight);
                command.Parameters.Add("addon1", bm.Addon1);
                command.Parameters.Add("addon2", bm.Addon2);
                command.Parameters.Add("netprice", bm.NetPrice);
                command.Parameters.Add("sellprice", bm.SellPrice);
                command.Parameters.Add("sellperfect", bm.SellPerfect);
                command.Parameters.Add("orderdate", bm.OrderDate);
                command.Parameters.Add("deliverydate", bm.DeliveryDate);
                command.Parameters.Add("instock", bm.InStock);
                command.Parameters.Add("minstock", bm.MinStock);
                command.Parameters.Add("maxstock", bm.MaxStock);
                command.Parameters.Add("minorder", bm.MinOrder);
                command.Parameters.Add("stockloc", bm.StockLoc);
                command.Parameters.Add("sparepart", bm.SparePart);
                command.Parameters.Add("webshop", bm.WebShop);
                command.Parameters.Add("remark", bm.Remark);
                command.Parameters.Add("mergecode", bm.MergeCode);
                command.Parameters.Add("derivedfrom", bm.DerivedFrom);
                command.Parameters.Add("remarkeng", bm.RemarkEng);
                command.Parameters.Add("keywords", bm.KeyWords);
                command.Parameters.Add("filter1", bm.Filter1);
                command.Parameters.Add("filter2", bm.Filter2);
                command.Parameters.Add("filter3", bm.Filter3);
                command.Parameters.Add("filter4", bm.Filter4);
                command.Parameters.Add("filter5", bm.Filter5);
                command.Parameters.Add("new_suppcode", bm.NewSuppCode);
                command.Parameters.Add("cust_code", bm.CustCode);
                command.Parameters.Add("matcode_suppl", bm.MatcodeSuppl);
                command.Parameters.Add("deleted", bm.Deleted);

                IDatabaseFactory dbFactory = new DatabaseFactory();
                IDatabase        dbObject  = dbFactory.CreateDatabaseInstance(ACTIVE_DATABASE);
                isInsert = dbObject.ExecuteQuery(command);
            }
            catch (Exception ex)
            {
                Hey.Common.Utils.LogWriter.Log(ex.Message);
            }
            return(isInsert);
        }
示例#13
0
 public void ShowToolTipMaterial(BaseMaterial material)
 {
     anim.SetTrigger("Show");
     Name.text     = material.Name;
     Consumes.text = "- Material";
     Produces.text = "-";
 }
示例#14
0
 /// <summary>
 /// Create an YnMeshGeometry with a geometry and a material.
 /// </summary>
 /// <param name="geometry">Geometry to use.</param>
 /// <param name="material">Material to use with geometry.</param>
 public YnMeshGeometry(BaseGeometry <VertexPositionNormalTexture> geometry, BaseMaterial material)
     : base()
 {
     _geometry            = geometry;
     _material            = material;
     _worldMatrixIsMaster = false;
 }
示例#15
0
    void DoOutput()
    {
        foreach (var item in space.Buildings)
        {
            if ((item.Output.ConsumeToGo == 0 && item.Output.TimeToGo == 0) || (!item.Input.enabled && item.Output.TimeToGo == 0))
            {
                //Debug.Log("should do output");
                SimpleCords spawnlocation = item.CenterLocation.OffsetBy(item.Output.DeliveryLocation);
                string      materialName  = item.Output.MaterialName;
                Tile        t             = space.Map.SaveGet(spawnlocation.x, spawnlocation.z);
                if (t.occupation == TileOccupation.Empty)
                {
                    BaseMaterial mat = materials.GetMaterialByName(materialName);
                    space.SpawnMaterial(mat, spawnlocation);

                    if (item.Input.enabled)
                    {
                        item.Output.ConsumeToGo = item.Output.ConsumeAmount;
                        item.Input.ConsumeToGo  = item.Input.ConsumeAmount;
                        item.Output.TimeToGo    = -1;
                    }
                    else
                    {
                        item.Output.TimeToGo = item.Output.DeliverTimer;
                    }
                    item.Clock.SetTimer(item.Output.TimeToGo);
                }
                item.Clock.SetTimer(item.Output.TimeToGo);
            }
        }
        ReportDone();
    }
示例#16
0
        public new BaseMaterial GetPred()
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.BaseMaterial_GetPred(swigCPtr);
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            return(ret);
        }
示例#17
0
 /// <summary>
 /// a tile needs its location for information, it automatically start empty
 /// </summary>
 /// <param name="position">position of the tile</param>
 public Tile(SimpleCords position)
 {
     this.position = position;
     Building      = null;
     Material      = null;
     occupation    = TileOccupation.Empty;
 }
示例#18
0
    private void DropMaterial()
    {
        if (isHolding)
        {
            moveState = MoveState.Return;
            bool contains = false;
            for (int i = 0; i < possiblePositions.Count; i++)
            {
                if (possiblePositions[i].Equals(holdPosition))
                {
                    contains = true;
                }
            }


            //Debug.Log("contains");
            MoveMaterial(originLocation, holdPosition, heldMaterial);
            // return to new location
            ObjectsToReturn.RemoveAll((x) => x.Key == heldMaterial.GameObject);
            ObjectsToReturn.Add(new KeyValuePair <GameObject, Vector3>(heldMaterial.GameObject, new Vector3(0, 0.50f, 0) + (Vector3)holdPosition));



            heldMaterial = null;
            isHolding    = false;
            holdTime     = 0f;

            HidePossiblePositions();
        }
    }
        protected override void OnClearBaseMaterial()
        {
            //clear material
            BaseMaterial.RemoveAllTechniques();

            base.OnClearBaseMaterial();
        }
示例#20
0
 public MaterialSource(string name, GameObject model, BaseMaterial baseMaterial, long quantityTotal) : base(name, model)
 {
     this.baseMaterial  = baseMaterial;
     this.quantityTotal = quantityTotal;
     this.quantity      = quantityTotal;
     this.canBuild      = true;
     this.building      = null;
 }
示例#21
0
    /// <summary>
    /// use this with unplaced Objects
    /// </summary>
    /// <param name="material">the material</param>
    /// <param name="location">position of placement</param>
    public void SpawnMaterial(BaseMaterial material, SimpleCords location)
    {
        Map[location.x, location.z].Material   = material;
        Map[location.x, location.z].occupation = TileOccupation.Material;

        material.Place(location);
        Materials.Add(material);
    }
示例#22
0
 protected HexahedralElement(SerializationInfo info, StreamingContext context)
     : base(info, context)
 {
     _e           = (double)info.GetValue("_e", typeof(double));
     _nu          = (double)info.GetValue("_nu", typeof(double));
     _massDensity = (double)info.GetValue("_massDensity", typeof(double));
     _material    = (BaseMaterial)info.GetValue("_material", typeof(int));
 }
 protected BarElement(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     _webRotation            = (double)info.GetValue("_webRotation", typeof(double));
     _material               = (BaseMaterial)info.GetValue("_material", typeof(BaseMaterial));
     _behavior               = (BarElementBehaviour)info.GetValue("_behavior", typeof(int));
     _section                = (Base1DSection)info.GetValue("_section", typeof(Base1DSection));
     _nodalReleaseConditions = (Constraint[])info.GetValue("_nodalReleaseConditions", typeof(Constraint[]));
 }
        void CreateFixedPipelineTechnique()
        {
            Technique tecnhique = BaseMaterial.CreateTechnique();
            Pass      pass      = tecnhique.CreatePass();

            pass.NormalizeNormals = true;

            pass.CreateTextureUnitState(ConvertToFullPath(DiffuseMap));
        }
示例#25
0
        public BaseMaterial[] GetMaterials()
        {
            BaseMaterial[] materials = new BaseMaterial[6];

            for (int i = 0; i < 6; i++)
            {
                materials[i] = (this[i] as YnMesh).Material;
            }

            return(materials);
        }
示例#26
0
    public Building Instantiate()
    {
        BaseMaterial producedBaseMaterial = null;

        if (producedMaterial != null)
        {
            producedBaseMaterial = producedMaterial.Instantiate();
        }

        return(new Building(id, name, Resources.Load(icon, typeof(Sprite)) as Sprite, Resources.Load(model, typeof(GameObject)) as GameObject, units, technologies, cost, size, lifeTotal, developTime, constructed, visionField, requireds, producedBaseMaterial, producedPerTime));
    }
示例#27
0
        public BaseMaterial SearchMaterialInc(string /* constString&_cstype */ str)
        {
            global::System.IntPtr cPtr = C4dApiPINVOKE.BaseDocument_SearchMaterialInc(swigCPtr, str);
            BaseMaterial          ret  = (BaseMaterial)C4dApiPINVOKE.InstantiateConcreteMaterial(cPtr, false);

            if (C4dApiPINVOKE.SWIGPendingException.Pending)
            {
                throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
示例#28
0
        protected virtual void DrawUserIndexedPrimitives(GraphicsDevice device, BaseMaterial material)
        {
            PreDraw(device);

            foreach (EffectPass pass in material.Effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                device.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, _vertices, 0, _vertices.Length, _indices, 0, _indices.Length / 3);
            }

            PostDraw(device);
        }
示例#29
0
文件: BaseZone.cs 项目: elavanis/Mud
        public IShield CreateShield(int level, BaseMaterial material = null)
        {
            IShield shield = new Shield();

            shield.Id       = ItemId++;
            shield.Zone     = Zone.Id;
            shield.Level    = level;
            shield.Dice     = GlobalReference.GlobalValues.DefaultValues.DiceForArmorLevel(level);
            shield.Material = material;

            return(shield);
        }
示例#30
0
    //public MaterialSource targetSource;

    public Worker(int idType, string name, Sprite icon, GameObject model, Dictionary <int, int> cost, float attack, float defense, float walkSpeed, float lifeTotal, int capacityTotal, float collectSpeed, List <int> buildings, float range, float attackSpeed, float trainingTime, int visionField) : base(idType, name, icon, model, cost, attack, defense, walkSpeed, lifeTotal, range, attackSpeed, trainingTime, visionField)
    {
        this.capacity         = 0;
        this.capacityTotal    = capacityTotal;
        this.collectSpeed     = collectSpeed;
        this.requiredBuilding = null;
        this.buildings        = buildings;
        //this.targetBuilding = null;
        this.collectTimeCounter = 0.0f;
        this.materialType       = null;
        //this.targetSource = null;
    }