Exemple #1
0
        void IView.SetLabelProps(ControlId labelId, string text, ModelColor color)
        {
            var ctrl = GetCtrl(labelId);

            ctrl.Text      = text;
            ctrl.ForeColor = color.ToColor();
        }
Exemple #2
0
        public void InsertModel(ModelDto newModelDto)
        {
            var newModel = new Model
            {
                Name        = newModelDto.Name,
                Description = newModelDto.Description,
                Photo       = newModelDto.Photo,
                Cost        = newModelDto.Cost,
                TypeId      = newModelDto.ShoesTypeId,
                Sex         = newModelDto.Sex,
                IsForKids   = newModelDto.IsForKids
            };

            _shoesDataEntities.Models.Add(newModel);
            newModelDto.AvailablesColors.ForEach(dto =>
            {
                var newModelColor = new ModelColor
                {
                    ColorId = dto.ColorId.Value,
                    ModelId = newModel.Id
                };
                _shoesDataEntities.ModelColors.Add(newModelColor);
            });
            SaveChanges();
        }
 public LJD.Pen GetTimeSeriesPen(ModelColor color)
 {
     LJD.Pen ret;
     if (!pensCache.TryGetValue(color, out ret))
     {
         pensCache.Add(color, ret = new LJD.Pen(color.ToColor(), 1));
     }
     return(ret);
 }
Exemple #4
0
 public static System.Drawing.Brush GetPaletteColorBrush(ModelColor color)
 {
     System.Drawing.Brush b;
     if (paletteColorBrushes.TryGetValue(color.Argb, out b))
     {
         return(b);
     }
     paletteColorBrushes.Add(color.Argb, b = new SolidBrush(color.ToColor()));
     return(b);
 }
 void Awake()
 {
     rainbowSpawn        = GameObject.FindGameObjectWithTag("Rainbow");
     firstClickTime      = 0;
     canSkill            = false;
     isFirstClick        = true;
     HP                  = 3;
     modelClearComponent = GetComponent <ModelClear>();
     modelMoveComponent  = GetComponent <ModelMove>();
     modelColorComponent = GetComponent <ModelColor>();
 }
Exemple #6
0
        void IView.SetLabelProps(ControlId labelId, string text, ModelColor color)
        {
            var ctrl = GetControl(labelId);

            if (ctrl == null)
            {
                return;
            }
            ctrl.StringValue = text;
            ctrl.TextColor   = color.ToColor().ToNSColor();
        }
Exemple #7
0
        public override int GetHashCode()
        {
            int hashCode = -1401498075;

            hashCode = hashCode * -1521134295 + EqualityComparer <char[]> .Default.GetHashCode(ModelData);

            hashCode = hashCode * -1521134295 + ModelBaseColor.GetHashCode();
            hashCode = hashCode * -1521134295 + ModelColor.GetHashCode();
            hashCode = hashCode * -1521134295 + BackgroundColor.GetHashCode();
            return(hashCode);
        }
        public static void DrawLegendSample(
            LJD.Graphics g,
            Resources resources,
            ModelColor color,
            MarkerType markerType,
            RectangleF rect
            )
        {
            g.PushState();
            g.EnableAntialiasing(true);
            var pen  = resources.GetTimeSeriesPen(color);
            var midX = (rect.X + rect.Right) / 2;
            var midY = (rect.Y + rect.Bottom) / 2;

            g.DrawLine(pen, rect.X, midY, rect.Right, midY);
            DrawPlotMarker(g, resources, pen, new PointF(midX, midY), markerType);
            g.PopState();
        }
Exemple #9
0
 void IViewEvents.OnColorSelected(ModelColor color)
 {
     source.Color = color;
 }
Exemple #10
0
 void IViewItem.SetBackColor(ModelColor color, bool isErrorColor)
 {
     base.BackColor = color.ToColor();
 }
        public static PlayerModel getModel(ContentManager content, ModelType type, ModelColor color)
        {
            Model normal, attack, walk;
            switch (type)
            {

                case ModelType.Legend:
                    switch (color)
                    {

                        case ModelColor.BLUE:

                            normal = content.Load<Model>("Bone/Legend/BLegend/BLegend(normal)");
                            walk = content.Load<Model>("Bone/Legend/BLegend/BLegend(walk)");
                            attack = content.Load<Model>("Bone/Legend/BLegend/BLegend(attack)");

                            break;
                        case ModelColor.RED:

                            normal = content.Load<Model>("Bone/Legend/RLegend/RLegend(normal)");
                            walk = content.Load<Model>("Bone/Legend/RLegend/RLegend(walk)");
                            attack = content.Load<Model>("Bone/Legend/RLegend/RLegend(attack)");
                            break;
                        case ModelColor.GREEN:

                            normal = content.Load<Model>("Bone/Legend/GLegend/GLegend(normal)");
                            walk = content.Load<Model>("Bone/Legend/GLegend/GLegend(walk)");
                            attack = content.Load<Model>("Bone/Legend/GLegend/GLegend(attack)");
                            break;
                        case ModelColor.ORANGE:

                            normal = content.Load<Model>("Bone/Legend/OLegend/OLegend(normal)");
                            walk = content.Load<Model>("Bone/Legend/OLegend/OLegend(walk)");
                            attack = content.Load<Model>("Bone/Legend/OLegend/OLegend(attack)");
                            break;
                        default:

                            normal = content.Load<Model>("Bone/Legend/RLegend/RLegend(walk)");
                            walk = content.Load<Model>("Bone/Legend/RLegend/RLegend(walk)");
                            attack = content.Load<Model>("Bone/Legend/RLegend/RLegend(attack)");
                            break;
                    }
                    break;
                case ModelType.SnowMan:
                    switch (color)
                    {
                        case ModelColor.BLUE:

                            normal = content.Load<Model>("Bone/SnowMan/BSnowMan/BSnowMan(normal)");
                            walk = content.Load<Model>("Bone/SnowMan/BSnowMan/BSnowMan(walk)");
                            attack = content.Load<Model>("Bone/SnowMan/BSnowMan/BSnowMan(attack)");

                            break;
                        case ModelColor.RED:

                            normal = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(normal)");
                            walk = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(walk)");
                            attack = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(attack)");
                            break;
                        case ModelColor.GREEN:

                            normal = content.Load<Model>("Bone/SnowMan/GSnowMan/GSnowMan(normal)");
                            walk = content.Load<Model>("Bone/SnowMan/GSnowMan/GSnowMan(walk)");
                            attack = content.Load<Model>("Bone/SnowMan/GSnowMan/GSnowMan(attack)");
                            break;
                        case ModelColor.ORANGE:

                            normal = content.Load<Model>("Bone/SnowMan/OSnowMan/OSnowMan(normal)");
                            walk = content.Load<Model>("Bone/SnowMan/OSnowMan/OSnowMan(walk)");
                            attack = content.Load<Model>("Bone/SnowMan/OSnowMan/OSnowMan(attack)");
                            break;
                        default:

                            normal = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(normal)");
                            walk = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(walk)");
                            attack = content.Load<Model>("Bone/SnowMan/RSnowMan/RSnowMan(attack)");
                            break;
                    }
                    break;
                case ModelType.Inoshishi:
                    switch (color)
                    {
                        case ModelColor.BLUE:

                            normal = content.Load<Model>("Bone/Inoshishi/BInoshishi/BInoshishi(normal)");
                            walk = content.Load<Model>("Bone/Inoshishi/BInoshishi/BInoshishi(walk)");
                            attack = content.Load<Model>("Bone/Inoshishi/BInoshishi/BInoshishi(attack)");
                            break;
                        case ModelColor.RED:
                            normal = content.Load<Model>("Bone/Inoshishi/RInoshishi/RInoshishi(normal)");
                            walk = content.Load<Model>("Bone/Inoshishi/RInoshishi/RInoshishi(walk)");
                            attack = content.Load<Model>("Bone/Inoshishi/RInoshishi/RInoshishi(attack)");
                            break;
                        case ModelColor.GREEN:
                            normal = content.Load<Model>("Bone/Inoshishi/GInoshishi/GInoshishi(normal)");
                            walk = content.Load<Model>("Bone/Inoshishi/GInoshishi/GInoshishi(walk)");
                            attack = content.Load<Model>("Bone/Inoshishi/GInoshishi/GInoshishi(attack)");
                            break;
                        case ModelColor.ORANGE:
                            normal = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(normal)");
                            walk = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(walk)");
                            attack = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(attack)");
                            break;
                        default:
                            normal = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(normal)");
                            walk = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(walk)");
                            attack = content.Load<Model>("Bone/Inoshishi/OInoshishi/OInoshishi(attack)");
                            break;
                    }
                    break;
                case ModelType.Metall:
                    switch (color)
                    {
                        case ModelColor.BLUE:
                            normal = content.Load<Model>("Bone/Metall/BMetall/BMetall(normal)");
                            walk = content.Load<Model>("Bone/Metall/BMetall/BMetall(walk)");
                            attack = content.Load<Model>("Bone/Metall/BMetall/BMetall(attack)");
                            break;
                        case ModelColor.RED:
                            normal = content.Load<Model>("Bone/Metall/RMetall/RMetall(normal)");
                            walk = content.Load<Model>("Bone/Metall/RMetall/RMetall(walk)");
                            attack = content.Load<Model>("Bone/Metall/RMetall/RMetall(attack)");
                            break;
                        case ModelColor.GREEN:
                            normal = content.Load<Model>("Bone/Metall/GMetall/GMetall(normal)");
                            walk = content.Load<Model>("Bone/Metall/GMetall/GMetall(walk)");
                            attack = content.Load<Model>("Bone/Metall/GMetall/GMetall(attack)");
                            break;
                        case ModelColor.ORANGE:
                            normal = content.Load<Model>("Bone/Metall/OMetall/OMetall(normal)");
                            walk = content.Load<Model>("Bone/Metall/OMetall/OMetall(walk)");
                            attack = content.Load<Model>("Bone/Metall/OMetall/OMetall(attack)");
                            break;
                        default:
                            normal = content.Load<Model>("Bone/Metall/OMetall/OMetall(normal)");
                            walk = content.Load<Model>("Bone/Metall/OMetall/OMetall(walk)");
                            attack = content.Load<Model>("Bone/Metall/OMetall/OMetall(attack)");
                            break;
                    }
                    break;
                default:
                    normal = content.Load<Model>("Bone/Metall/OMetall/OMetall(normal)");
                    walk = content.Load<Model>("Bone/Metall/OMetall/OMetall(walk)");
                    attack = content.Load<Model>("Bone/Metall/OMetall/OMetall(attack)");
                    break;
            }
            return new PlayerModel(normal, attack, walk);
        }
Exemple #12
0
 static Brush MakeBrush(ModelColor c)
 {
     return(new SolidBrush(Color.FromArgb(c.R, c.G, c.B)));
 }
 /// <summary>
 /// 初期設定用。
 /// </summary>
 /// <param name="index"></param>
 /// <param name="type"></param>
 /// <param name="color"></param>
 private void setModelTypeAndColor(PlayerIndex index,ModelType type,ModelColor color)
 {
     modelTypes[index] = type;
     setModelColor(index, color);
 }
 /// <summary>
 /// プレイヤーの色を変える
 /// 保持しているモデルも変わります
 /// </summary>
 /// <param name="index"></param>
 public void setModelColor(PlayerIndex index, ModelColor modelcolor)
 {
     modelColors[index] = modelcolor;
     ModelType type;
     modelTypes.TryGetValue(index, out type);
     models[index] = PlayerModelGenerator.getModel(content, type, modelcolor);
     foreach (PlayerIndex playerIndex in Enum.GetValues(typeof(PlayerIndex)))
     {
         charactorConflict[playerIndex] = isConflict(playerIndex);
     }
 }
 void IViewItem.SetBackColor(ModelColor color, bool isFailureColor)
 {
     this.color = isFailureColor ? color : new ModelColor?();
     Update();
 }
Exemple #16
0
 /// <summary>
 /// モデルのファイルパス
 /// </summary>
 /// <param name="modelType"></param>
 /// <param name="modelColor"></param>
 /// <param name="modelAnimation"></param>
 /// <returns></returns>
 public static String GetModelPath(ModelType modelType, ModelColor modelColor, ModelAnimation modelAnimation)
 {
     String filePath = DirBWave;
     switch (modelType)
     {
         case ModelType.Metall:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirBMetallN;
                         case ModelAnimation.WALK:
                             return DirBMetallW;
                         case ModelAnimation.ATTACK:
                             return DirBMetallA;
                     }
                     break;
                 case ModelColor.RED:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirRMetallN;
                         case ModelAnimation.WALK:
                             return DirRMetallW;
                         case ModelAnimation.ATTACK:
                             return DirRMetallA;
                     }
                     break;
                 case ModelColor.GREEN:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirGMetallN;
                         case ModelAnimation.WALK:
                             return DirGMetallW;
                         case ModelAnimation.ATTACK:
                             return DirGMetallA;
                     }
                     break;
                 case ModelColor.ORANGE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirOMetallN;
                         case ModelAnimation.WALK:
                             return DirOMetallW;
                         case ModelAnimation.ATTACK:
                             return DirOMetallA;
                     }
                     break;
             }
             break;
         case ModelType.Legend:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirBLegendN;
                         case ModelAnimation.WALK:
                             return DirBLegendW;
                         case ModelAnimation.ATTACK:
                             return DirBLegendA;
                     }
                     break;
                 case ModelColor.RED:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirRLegendN;
                         case ModelAnimation.WALK:
                             return DirRLegendW;
                         case ModelAnimation.ATTACK:
                             return DirRLegendA;
                     }
                     break;
                 case ModelColor.GREEN:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirGLegendN;
                         case ModelAnimation.WALK:
                             return DirGLegendW;
                         case ModelAnimation.ATTACK:
                             return DirGLegendA;
                     }
                     break;
                 case ModelColor.ORANGE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirOLegendN;
                         case ModelAnimation.WALK:
                             return DirOLegendW;
                         case ModelAnimation.ATTACK:
                             return DirOLegendA;
                     }
                     break;
             }
             break;
         case ModelType.SnowMan:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirBSnowManN;
                         case ModelAnimation.WALK:
                             return DirBSnowManW;
                         case ModelAnimation.ATTACK:
                             return DirBSnowManA;
                     }
                     break;
                 case ModelColor.RED:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirRSnowManN;
                         case ModelAnimation.WALK:
                             return DirRSnowManW;
                         case ModelAnimation.ATTACK:
                             return DirRSnowManA;
                     }
                     break;
                 case ModelColor.GREEN:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirGSnowManN;
                         case ModelAnimation.WALK:
                             return DirGSnowManW;
                         case ModelAnimation.ATTACK:
                             return DirGSnowManA;
                     }
                     break;
                 case ModelColor.ORANGE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirOSnowManN;
                         case ModelAnimation.WALK:
                             return DirOSnowManW;
                         case ModelAnimation.ATTACK:
                             return DirOSnowManA;
                     }
                     break;
             }
             break;
         case ModelType.Inoshishi:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirBInoshishiN;
                         case ModelAnimation.WALK:
                             return DirBInoshishiW;
                         case ModelAnimation.ATTACK:
                             return DirBInoshishiA;
                     }
                     break;
                 case ModelColor.RED:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirRInoshishiN;
                         case ModelAnimation.WALK:
                             return DirRInoshishiW;
                         case ModelAnimation.ATTACK:
                             return DirRInoshishiA;
                     }
                     break;
                 case ModelColor.GREEN:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirGInoshishiN;
                         case ModelAnimation.WALK:
                             return DirGInoshishiW;
                         case ModelAnimation.ATTACK:
                             return DirGInoshishiA;
                     }
                     break;
                 case ModelColor.ORANGE:
                     switch (modelAnimation)
                     {
                         case ModelAnimation.NORMAL:
                             return DirOInoshishiN;
                         case ModelAnimation.WALK:
                             return DirOInoshishiW;
                         case ModelAnimation.ATTACK:
                             return DirOInoshishiA;
                     }
                     break;
             }
             break;
         case ModelType.Wave:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBWave;
                 case ModelColor.RED:
                     return DirRWave;;
                 case ModelColor.GREEN:
                     return DirGWave;
                 case ModelColor.ORANGE:
                     return DirOWave;
             }
             break;
     }
     return DirBWave;
 }
Exemple #17
0
 /// <summary>
 /// モデルのファイルパス取得
 /// </summary>
 /// <param name="modelType"></param>
 /// <param name="modelColor"></param>
 /// <returns></returns>
 public static String GetModelPath(ModelType modelType, ModelColor modelColor)
 {
     String filePath = DirBWave;
     switch (modelType)
     {
         case ModelType.Metall:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBMetallN;
                 case ModelColor.RED:
                     return DirRMetallN;
                 case ModelColor.GREEN:
                     return DirGMetallN;
                 case ModelColor.ORANGE:
                     return DirOMetallN;
             }
             break;
         case ModelType.Legend:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBMetallN;
                 case ModelColor.RED:
                     return DirRMetallN;
                 case ModelColor.GREEN:
                     return DirGMetallN;
                 case ModelColor.ORANGE:
                     return DirOMetallN;
             }
             break;
         case ModelType.SnowMan:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBMetallN;
                 case ModelColor.RED:
                     return DirRMetallN;
                 case ModelColor.GREEN:
                     return DirGMetallN;
                 case ModelColor.ORANGE:
                     return DirOMetallN;
             }
             break;
         case ModelType.Inoshishi:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBMetallN;
                 case ModelColor.RED:
                     return DirRMetallN;
                 case ModelColor.GREEN:
                     return DirGMetallN;
                 case ModelColor.ORANGE:
                     return DirOMetallN;
             }
             break;
         case ModelType.Wave:
             switch (modelColor)
             {
                 case ModelColor.BLUE:
                     return DirBMetallN;
                 case ModelColor.RED:
                     return DirRMetallN;
                 case ModelColor.GREEN:
                     return DirGMetallN;
                 case ModelColor.ORANGE:
                     return DirOMetallN;
             }
             break;
     }
     return DirBWave;
 }
 public static LJD.Brush MakeBrush(ModelColor c)
 {
     return(new LJD.Brush(Color.FromArgb(c.R, c.G, c.B)));
 }
Exemple #19
0
        public override void DrawMesh(ICubismTexture itexture, float[] vertex_buffer, float[] uv_buffer, short[] index_buffer, ICubismClippingMask iclipping_mask, Matrix clipping_matrix, BlendModeType blend_mode, bool use_culling, double opacity)
        {
            var  texture           = (CubismOpenGlNetTexture)itexture;
            var  clipping_mask     = iclipping_mask as CubismOpenGlNetClippingMask;
            bool use_clipping_mask = (clipping_mask != null);

            UseCulling = use_culling;
            BlendMode  = blend_mode;

            var shader = ShaderManager.ShaderForDrawMesh(use_clipping_mask, UsePremultipliedAlpha);

            Gl.UseProgram(shader.ProgramId);

            // 頂点バッファを設定する
            Gl.EnableVertexAttribArray((uint)shader.AttributePositionLocation);
            GCHandle pinned_vertex_buffer = GCHandle.Alloc(vertex_buffer, GCHandleType.Pinned);

            Gl.VertexAttribPointer((uint)shader.AttributePositionLocation, 2, VertexAttribType.Float, false, sizeof(float) * 2, pinned_vertex_buffer.AddrOfPinnedObject());

            // UVバッファを設定する
            Gl.EnableVertexAttribArray((uint)shader.AttributeTexCoordLocation);
            GCHandle pinned_uv_buffer = GCHandle.Alloc(uv_buffer, GCHandleType.Pinned);

            Gl.VertexAttribPointer((uint)shader.AttributeTexCoordLocation, 2, VertexAttribType.Float, false, sizeof(float) * 2, pinned_uv_buffer.AddrOfPinnedObject());

            if (use_clipping_mask == true)
            {
                Gl.ActiveTexture(TextureUnit.Texture1);
                Gl.BindTexture(TextureTarget.Texture2d, clipping_mask.TextureId);
                Gl.Uniform1(shader.SamplerTexture1Location, 1);

                // View座標をClippingContextの座標に変換するための行列を設定
                Gl.UniformMatrix4(shader.UniformClipMatrixLocation, false, clipping_matrix.AsColumnMajorArray());

                // 使用するカラーチャンネルを設定
                Gl.Uniform4(shader.UnifromChannelFlagLocation, 1.0f, 0.0f, 0.0f, 0.0f);
            }
            else
            {
                Gl.ActiveTexture(TextureUnit.Texture1);
                Gl.BindTexture(TextureTarget.Texture2d, 0);
            }

            //テクスチャ設定
            Gl.ActiveTexture(TextureUnit.Texture0);
            Gl.BindTexture(TextureTarget.Texture2d, texture.TextureId);
            Gl.Uniform1(shader.SamplerTexture0Location, 0);

            // 座標変換
            Gl.UniformMatrix4(shader.UniformMatrixLocation, false, MvpMatrix.AsColumnMajorArray());

            // モデルの色を設定する
            float[] color = new float[4];
            ModelColor.CopyTo(color, 0);
            color[3] *= (float)opacity;
            if (UsePremultipliedAlpha == true)
            {
                color[0] *= color[3];
                color[1] *= color[3];
                color[2] *= color[3];
            }
            Gl.Uniform4(shader.UniformBaseColorLocation, color[0], color[1], color[2], color[3]);

            // 描画する
            GCHandle pinned_index_buffer = GCHandle.Alloc(index_buffer, GCHandleType.Pinned);

            Gl.DrawElements(PrimitiveType.Triangles, index_buffer.Length, DrawElementsType.UnsignedShort, pinned_index_buffer.AddrOfPinnedObject());

            // バッファのアドレスの固定を解除する
            pinned_vertex_buffer.Free();
            pinned_uv_buffer.Free();
            pinned_index_buffer.Free();
        }