Esempio n. 1
0
    public GrassV2zone(GrassV2zone model)
    {
        m_pixels = new List<MaskPixRGB>();
        for(int i=0; i<model.m_pixels.Count; i++)
            m_pixels.Add(new MaskPixRGB(model.m_pixels[i]));

        m_bounds = model.m_bounds;
        m_textureID = model.m_textureID;
        m_texGen = model.m_texGen;
    }
Esempio n. 2
0
    private LinkedList<IEv2_Zone> m_zonesVec; // zones en vectoriel

    #endregion Fields

    #region Methods

    //----------------------------------------------------
    public void AddZone(IEv2_Zone newZone)
    {
        m_zonesVec.AddLast(newZone);

        // -- Construction de la zone --
        GrassV2zone gZone = newZone.RasterizeRGB(new Rect(0f, 0f, m_mask.width, m_mask.height));
        if(newZone.GetMainColor() == Color.clear)
            gZone.m_textureID = -1;
        else
            gZone.m_textureID = m_grassSkybox.GetComponent<GrassHandler>().GetCurTexID();
        gZone.m_texGen = m_grassSkybox.GetComponent<GrassHandler>().GetSynthTexGen();
        //        Debug.Log(DEBUGTAG+"Zone ADDED : "+gZone.m_textureID+", "+(gZone.m_texGen != null ? gZone.m_texGen.ToString() : "null"));

        m_grassBuffer = m_grassSkybox.GetComponent<GrassHandler>().GetGrassImage(m_maskSizeDiv,
                                                                                    gZone.m_bounds);
        //        m_grassBuffer.Apply(false); // debug : pour voir la texture dans l'inspecteur

        if(newZone.GetMainColor() != Color.clear)
        {
            List<MaskPixRGB> pix = gZone.m_pixels;
            for(int i=0; i<pix.Count; i++)
            {
                int x = pix[i].GetX() - (int)gZone.m_bounds.x;
                int y = pix[i].GetY() - (int)gZone.m_bounds.z;
                pix[i].SetColor(m_grassBuffer.GetPixel(x, y));
            }
        }
        //        Debug.Log (DEBUGTAG+"ADDING Zone : "+pix.Count+" pixels");

        m_updatedZone = gZone;
        m_zones.AddLast(m_updatedZone);
        m_backupZones.Add(new GrassV2zone(gZone));
        m_undoedZones.Clear();                 // Supprimer zones annulées (plus de redo possible)

        m_needMaskUpdate = true;
        m_zoneAdded = true;
        m_mainScene.GetComponent<PleaseWaitUI>().SetDisplayIcon(true);

        SetVisible(true);
    }
Esempio n. 3
0
    //-----------------------------------------------------
    public void UndoLastZone()
    {
        // Annuler si la limite d'annulations n'est pas atteinte,
        // ou bien s'il reste une seule zone qui n'a pas été fusionnée au préalable
        if(m_zones.Count >= 1 && m_undoedZones.Count < m_maxUndoCount && m_backupZones.Count > 0)
        {
            m_undoedZones.Push(m_zones.Last.Value);   // Ajouter la zone annulée aux zones d'undo
            m_zones.RemoveLast();                     // Supprimer la zone annulée des zones gommées
            m_undoedZoneVec.Push(m_zonesVec.Last.Value);
            m_zonesVec.RemoveLast();                  // Idem pour les zones vectorielles

            m_mainScene.GetComponent<PleaseWaitUI>().SetDisplayIcon(true);
            m_updatedZone = m_backupZones[m_backupZones.Count-1];
            m_zoneAdded = false;                           // Mettre à jour l'image en rétablissant les pixels de l'ancienne zone
            m_needMaskUpdate = true;
            m_backupZones.RemoveAt(m_backupZones.Count-1); // Supprimer l'ancienne zone
        }
        else
            Debug.Log(DEBUGTAG+"Can't undo. Undo limit (" + m_maxUndoCount + ") reached ?");
    }
Esempio n. 4
0
    //-----------------------------------------------------
    private IEnumerator UpdateMask(GrassV2zone newZone, bool apply, bool added)
    {
        m_updatingCount++;

        // -- Application des pixels de la zone au masque --
        List<MaskPixRGB> pixels = newZone.m_pixels;

        List<MaskPixRGB> bkPix = (added ? m_backupZones[m_backupZones.Count-1].m_pixels : null);
        for(int i=0; i<pixels.Count; i++)
        {
            int x = (int)(pixels[i].GetX()/(float)m_maskSizeDiv);
            int y = (int)(pixels[i].GetY()/(float)m_maskSizeDiv);

            for(int j=0; j<m_maskSizeDiv; j++)
            {
                for(int k=0; k<m_maskSizeDiv; k++)
                {
                    if(added)
                    {
                        bkPix[i].SetColor(m_mask.GetPixel(x+j, y+k));  // Sauvegarde pour futur undo
        //                        Debug.Log (m_mask.GetPixel(x+j, y+k));
                    }
                    m_mask.SetPixel(x+j, y+k, pixels[i].GetColor());   // Application nouveau pixel
                }
            }
        } // foreach pixel
        //        Debug.Log(DEBUGTAG+" Updating grass ... "+pixels.Count+" pixels written on mask = "+m_mask.width+", "+m_mask.height);

        //        for(int i=0; i<pixels.Count; i++)
        //            Debug.Log("yoho "+m_backupZones[m_backupZones.Count-1].m_pixels[i].GetColor().ToString());

        if(apply)
            StartCoroutine(ApplyMask());

        m_updatingCount--;
        yield return null;
    }
Esempio n. 5
0
    //----------------------------------------------------
    public void Redo()
    {
        if(m_undoedZones.Count > 0)
        {
            m_zones.AddLast(m_undoedZones.Pop());
            m_zonesVec.AddLast(m_undoedZoneVec.Pop());

            m_backupZones.Add(new GrassV2zone(m_zones.Last.Value));
            m_mainScene.GetComponent<PleaseWaitUI>().SetDisplayIcon(true);
            m_updatedZone = m_zones.Last.Value;
            m_needMaskUpdate = true;
            m_zoneAdded = true;
        }
        else
            Debug.Log(DEBUGTAG+"Nothing to redo");
    }