Vai al contenuto

Edit Style
Primary: Sky Slate Blackcurrant Watermelon Strawberry Orange Banana Apple Emerald Chocolate Marble
Secondary: Sky Slate Blackcurrant Watermelon Strawberry Orange Banana Apple Emerald Chocolate Marble
Pattern: Blank Waves Squares Notes Sharp Wood Rockface Leather Honey Vertical Triangles
Welcome to Blender ITALIA
Register now to gain access to all of our features. Once registered and logged in, you will be able to create topics, post replies to existing threads, give reputation to your fellow members, get your own private messenger, post status updates, manage your profile and so much more. This message will be removed once you have signed in.
Login to Account Create an Account


Foto

Vertex slide - Aggiornato 28/02/2012 (BMesh version)


  • Per cortesia connettiti per rispondere
100 risposte a questa discussione

#1
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Posto anche qua caso mai potesse servire a qualcuno (vero Lell?) :)
############################
EDIT: Aggiornato primo post, ora è più pulito
############################

Questo script permette di aggiungere la funzionalità Vertex slide.

Link alla the wiki: Wiki
Link al Tracker: Tracker
Per scaricarlo andare nella Wiki e seguite il collegamento indicato.

Con 2 vertici selezionati:
Con la rotella del mouse si seleziona il vertice da spostare (quello con un * vicino)
Ogni volta che si cambia vertice, il vertice torna nella posizione originale e da lì inizia a muoversi.
Tenere premuto ALT di sinistra per far partire il movimento dall'ultima posizione e non dalla posizione originale.
Non è necessario che i due vertici siano collegati. È possibile selezionare 2 vertici qualsiasi della mesh. Se si seleziona più di due vertici, lo script utilizzerà i due vertici con indice minore.

Con 1 vertice selezionato:
Con la rotella del mouse si seleziona il bordo lungo cui far scorrere il vertice.
Ogni volta che si cambia il bordo, il vertice torna nella posizione originale e da lì inizia a muoversi.
Tenere premuto ALT di sinistra per far partire il movimento dall'ultima posizione e non dalla posizione originale.

Premendo + del tastierino numerico si inverte il movimento del vertice rispetto al movimento del mouse, premere + del tastierino numerico per ripristinare.
Premendo SHIFT di sinistra si ha un movimento più lento/preciso


Ciao
Valter




#2
Seregost

Seregost

    Moderator

  • Moderators
  • 5617 messaggi
  • LocationTerzo di Aquileia
Mitico :cool:

Se non sbaglio c'era gia qualcosa a riguardo, solo che se non erro il tizio che l'aveva fatto era giapponese e dopo il disastro che hanno avuto non si sono più trovate delle build con questa funzione.

Parere personale: la rotella è scomoda, non si potrebbe fare come per l'edge slide che funziona con i movimenti del mouse?
Immagine inserita REGOLAMENTO FORUM: !!LEGGERE PLEASE!!
Immagine inserita GUIDA BLENDER 2.5: DOWNLOAD GUIDA ITALIANO
Immagine inserita BLENDER PRINCIPIANTI: GUIDA PER PRINCIPIANTI ASSOLUTI

#3
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Perché scomoda? a me sembrava la soluzione ideale :)

Comunque ci posso provare, poi apro un sondaggio :grin:

#4
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Ma l'hai scritto tu? Hai visto il mio topic su blender artist? Secondo me la mia soluzione è l'ideale. Metto anche qui lo schema, così seregost mi dice se gli piace.
http://blenderartist...de-for-vertices

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#5
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Lell: Il grande fratello sa tutto e vede tutto :mrgreen:

Allora, si può fare: vediamo se ho capito:
1) Con la rotella scegli quale dei 2 vertici spostare; a ogni rotazione della rotella scambio il punto da muovere

2) Con il movimento del mouse esegui lo spostamento.

La seguente domanda mi sorge spontanea:
Il vertice si può spostare solo lungo un asse, quello che passa idealmente per i 2 vertici, ma il mouse si sposta su 2 assi, dx/sx alto/basso, come vorreste sfruttare il movimento del mouse?
Considero solo dx/sx o alto/basso? o aveviate qualcos'altro in mente?

Con l'edge slide, che ha effettivamente 2 gradi di movimento era corretto utilizzare il movimento del mouse, ma con il vertex slide non rischia di confondere un po'? Muovo dx sx e succede qualcosa, muovo alto/basso non succede niente o viceversa.

#6
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
No, con la rotella cambi l'edge sul quale si muove il vertice. Il vertice che si muove è quello selezionato, e il comando si avvia sempre premendo Edge slide. Ti ricordi che nella 2.49 quando facevi edge slide potevi cambiare l'edge di riferimento del movimento? Era utile perchè non avevi il continuous grab come ora. Non potevi uscire dallo schermo col mouse, e quindi in certi casi il movimento dello stesso non era sufficiente ad eseguire l'operazione. Dovevi ruotare la rotella in modo che l'edre di riferimento fosse quello che vedevi. In pratica si reintegra questa soluzione nel vertex slide.
Puoi fare che si muova con uno qualunque dei due movimenti. Non mi risulta che con l'edge slide succedano due cose in base alla direzione del movimento del mouse.

Ho guardato, e Blender considera il valore dello spostamento sia che si muova dx/sx, sia alto/basso.

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#7
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Buttato giù velocemente solo se per capire spostare con il mouse il vertice è meglio.
Ora il movimento del vertice è comandato dal movimento dx/sx del mouse.

Nello script del primo post ho aggiunto la possibilità di usare il tasto SHIFT per avere un movimento più preciso.

Non mi risulta che con l'edge slide succedano due cose in base alla direzione del movimento del mouse

sono stato fregato da una prova che avevo fatto sulo cubo. :)

con la rotella cambi l'edge sul quale si muove il vertice


Non so se ho capito, ho provato l'edge slide sulla 2.49 che conosco poco ma non ho capito che succede muovendo la rotella:
Intendi dire: seleziono 1 solo vertice, attivo l'operatore, ruotando la rotella seleziono uno degli altri vertici collegati direttamente al vertice selezionato?
Se si penso di riuscirci, devo solo trovare il comando per i vertici collegati.
Inoltre in questo caso penso di poter mantenere tutte e 2 le funzionalità: se ho un solo vertice selezionato, uso ques'ultimo sistema, se no uso il sistema precedente.


Fammi sapere se intendevi questo.

import bpy
from bpy.props import IntProperty, FloatProperty, FloatVectorProperty
from mathutils import Vector

def NewCo(v0,v1,t):
    #Equation of the line
    x = v0.x + (v1.x - v0.x) * t
    y = v0.y + (v1.y - v0.y) * t
    z = v0.z + (v1.z - v0.z) * t
    return Vector((x,y,z))


class ModalOperator(bpy.types.Operator):
    bl_idname = "vertex.slide"
    bl_label = "Vertex Slide"

    vert_1_index = -1
    vert_1_co = []

    vert_2_index = -1
    vert_2_co = []

    cont = 0
    step = 0.1
    offset = FloatVectorProperty(name="Offset", size=3)
    #Used for toggle from the first and the second vertex
    left_alt=False 
    #Used for toggle from/to normal to/from precision
    shift=False
    MouseX=0
    MouseY=0
    
    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':
            Vertices = bpy.context.object.data.vertices
            bpy.ops.object.mode_set(mode='OBJECT')
            if self.left_alt:
                Vertices[self.vert_1_index].co =  NewCo(Vertices[self.vert_1_index].co, Vertices[self.vert_2_index].co,(event.mouse_x-self.MouseX)/100 )
            else:
                Vertices[self.vert_2_index].co =  NewCo(Vertices[self.vert_2_index].co, Vertices[self.vert_1_index].co,(event.mouse_x-self.MouseX)/100 )
            self.MouseX=event.mouse_x
            bpy.ops.object.mode_set(mode='EDIT')
            

        #Cancel
        elif event.type in ('RIGHTMOUSE', 'ESC'):
            obj = bpy.context.object
            bpy.ops.object.mode_set(mode='OBJECT')
            obj.data.vertices[self.vert_1_index].co = self.vert_1_co
            obj.data.vertices[self.vert_2_index].co = self.vert_2_co
            bpy.ops.object.mode_set(mode='EDIT')
            return {'CANCELLED'}

        elif event.type == 'LEFTMOUSE':
            return {'FINISHED'}

        elif event.type=='LEFT_ALT':
            self.left_alt = not self.left_alt

        elif event.type == 'LEFT_SHIFT':
            if self.step == 0.1:
                self.step = 0.01
            else:
                self.step = 0.1

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        if context.object:
            self._initial_mouse = Vector((event.mouse_x, event.mouse_y, 0.0))
            self.MouseX=event.mouse_x
            self.MouseY=event.mouse_y
            obj = bpy.context.object
            bpy.ops.object.mode_set(mode='OBJECT')
            #Store the original coordinates for Cancel
            for vert in obj.data.vertices:
                if vert.select and self.vert_1_index == -1:
                    self.vert_1_index = vert.index
                    self.vert_1_co = Vector((vert.co.x,vert.co.y,vert.co.z))
                elif vert.select and self.vert_2_index == -1 and vert.index != self.vert_1_index:
                    self.vert_2_index = vert.index
                    self.vert_2_co = Vector((vert.co.x,vert.co.y,vert.co.z))
            bpy.ops.object.mode_set(mode='EDIT')
            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "No active object, could not finish")
            return {'CANCELLED'}

def register():
    bpy.utils.register_class(ModalOperator)


def unregister():
    bpy.utils.unregister_class(ModalOperator)


if __name__ == "__main__":
    register()


#8
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Vedi la linea verde? Lui prende quell'edge per decidere dove mettere il nuovo loop, in base alla posizione del mouse. Se ruoti la rotella la linea verde si sposta e il riferimento per il mouse cambia. Questo per l'edge slide nella 2.49. Per il vertex slide questo non serve, ma serve poter decidere su quale edge far muovere il vertice. Questo lo indichiamo con la rotella, scorrendo i vari edge disponibili, che si evidenziano di viola o verde o quello che vuoi.
Il vertice da muovere va selezionato prima ovviamente. Poi si sceglie edge slide o altro comando apposito e col movimento del mouse lo si posiziona. Click e fine.

Chiaro ora? :smile:

File Allegati

  • File Allegati  Slide.jpg   217,38K   8 Numero di downloads

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#9
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Ho capito cosa volevi dire. In pratica è la stessa cosa che dicevo io, solo che a me non interessa che si veda il secondo vertice selezionato, ma l'edge rul quale si muove. Ma la tua idea in effetti, della doppia possibilità può andare!

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#10
Seregost

Seregost

    Moderator

  • Moderators
  • 5617 messaggi
  • LocationTerzo di Aquileia
Non sono d'accordo sul farlo lavorare sullo stesso comando dell'edge slide, io farei un comando a se tipo Ctrl+V->Vertex-slide, anche per coerenza. Concordo sull'opzione della rotella per decidere l'edge sul quale muoversi.
Immagine inserita REGOLAMENTO FORUM: !!LEGGERE PLEASE!!
Immagine inserita GUIDA BLENDER 2.5: DOWNLOAD GUIDA ITALIANO
Immagine inserita BLENDER PRINCIPIANTI: GUIDA PER PRINCIPIANTI ASSOLUTI

#11
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Un passo alla volta prima devo farlo :)

Comunque pensavo di metterlo sotto gli Special. Tasto W in Edit mode

#12
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Se proprio non volete metterlo sugli edge specials, allora voto per l'idea di seregost, che almeno ha una sua logica. Io dicevo di metterlo con l'edge slide in modo che uno che sta sistemando una topologia usa sempre quel comando. Comunque va bene anche nei vertex specials!

Ma anche in tutti e due comunque, come altri comandi che sono in entrambi i menù! Ma mettiamolo su tutti e tre! Perchè no? :cool:

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#13
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Ora dovrebbe funzionare, provate e fatemi sapere.

Se quando lanciate l'operatore, c'è selezionato un solo vertice, allora la rotella del mouse permette di selezionare, uno per volta tutti i vertici collegati, muovendo il mouse a dx o a sx, si sposta il vertice lungo la linea di congiunzione fra i 2 vertici evidenziati. Lo shift permette un movimento più preciso.

Se quando lanciate l'operatore, ci sono 2 vertici selezionati, muovendo il mouse si sposta uno dei 2 vertici lungo la linea di congiunzione fra i 2 vertici evidenziati. Naturalmente non serve che i 2 vertici siano collegati, ma possono essere presi da qualsiasi parte della Mesh, premendo ALT di sx si muove l'altro vertice. Lo SHIFT permette un movimento più preciso.

Se quando lanciate l'operatore, ci sono più di 2 vertivi selezionati, lo script prende in considerazione solo i primi due (se vi può servire, prende quelli con indice più basso).

Premere tasto sx del mouse per confermare, tasto dx per annullare.

Non l'ho ancora messo sotto menù, ho qualche problema da risolvere, quindi va lanciato come l'altro.
Copia e incolla dello script, ALT P per eseguirlo, poi in EDIT mode premere SPAZIO e digitare slide quindi selezionare Vertex Slide.

Ciao
Valter

import bpy
from bpy.props import IntProperty, FloatProperty, FloatVectorProperty
from mathutils import Vector

def NewCo(v0,v1,t):
    #Equation of the line
    x = v0.x + (v1.x - v0.x) * t
    y = v0.y + (v1.y - v0.y) * t
    z = v0.z + (v1.z - v0.z) * t
    return Vector((x,y,z))


class ModalOperator(bpy.types.Operator):
    bl_idname = "vertex.slide"
    bl_label = "Vertex Slide"

    vert_1_index = -1
    vert_1_co = []

    vert_2_index = -1
    vert_2_co = []

    cont = 0
    step = 100
    offset = FloatVectorProperty(name="Offset", size=3)
    
    left_alt=False  #Used for toggle from the first and the second vertex
    shift=False  #Used for toggle from/to normal to/from precision
    
    MouseX=0
    MouseY=0
    
    Vert=[]
    SecondVertIndex=0
    
    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':
            if self.vert_2_index != -1:
                Vertices = bpy.context.object.data.vertices
                bpy.ops.object.mode_set(mode='OBJECT')
                if self.left_alt:
                    Vertices[self.vert_1_index].co =  NewCo(Vertices[self.vert_1_index].co, Vertices[self.vert_2_index].co,(event.mouse_x-self.MouseX)/self.step )
                else:
                    Vertices[self.vert_2_index].co =  NewCo(Vertices[self.vert_2_index].co, Vertices[self.vert_1_index].co,(event.mouse_x-self.MouseX)/self.step )
                self.MouseX=event.mouse_x
                bpy.ops.object.mode_set(mode='EDIT')
            else:
                Vertices = bpy.context.object.data.vertices
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].co =  NewCo(Vertices[self.vert_1_index].co, Vertices[self.Vert[self.SecondVertIndex]].co,(event.mouse_x-self.MouseX)/self.step )
                self.MouseX=event.mouse_x
                bpy.ops.object.mode_set(mode='EDIT')

        if event.type == 'WHEELDOWNMOUSE':
            if self.vert_2_index == -1:
                Vertices = bpy.context.object.data.vertices
                self.SecondVertIndex =self.SecondVertIndex+ 1
                if self.SecondVertIndex >= len(self.Vert)-1:
                    self.SecondVertIndex = len(self.Vert)-1
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.Vert[self.SecondVertIndex]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
        
        if event.type == 'WHEELUPMOUSE':
            if self.vert_2_index == -1:
                Vertices = bpy.context.object.data.vertices
                self.SecondVertIndex =self.SecondVertIndex- 1
                if self.SecondVertIndex < 0:
                    self.SecondVertIndex = 0
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.Vert[self.SecondVertIndex]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
        
        elif event.type == 'LEFTMOUSE':
            Vertices = bpy.context.object.data.vertices
            if self.vert_2_index == -1:
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            else:
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.vert_2_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            return {'FINISHED'}

        elif event.type=='LEFT_ALT':
            self.left_alt = not self.left_alt

        elif event.type == 'LEFT_SHIFT':
            if self.step == 100:
                self.step = 1000
            else:
                self.step = 100

        elif event.type in ('RIGHTMOUSE', 'ESC'):  #Restore and exit
            Vertices = bpy.context.object.data.vertices
            bpy.ops.object.mode_set(mode='OBJECT')
            Vertices[self.vert_1_index].co = self.vert_1_co
            if self.vert_2_index != -1:
                Vertices[self.vert_2_index].co = self.vert_2_co
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.vert_2_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            else:
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            bpy.ops.object.mode_set(mode='EDIT')
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        #verificare se serve azzerare le variabili self
        if context.object:
            self._initial_mouse = Vector((event.mouse_x, event.mouse_y, 0.0))
            self.MouseX=event.mouse_x
            self.MouseY=event.mouse_y
            obj = bpy.context.object
            bpy.ops.object.mode_set(mode='OBJECT')
            #Store the original coordinates for Cancel
            for vert in obj.data.vertices:
                if vert.select and self.vert_1_index == -1:
                    self.vert_1_index = vert.index
                    self.vert_1_co = Vector((vert.co.x,vert.co.y,vert.co.z))
                elif vert.select and self.vert_2_index == -1 and vert.index != self.vert_1_index:
                    self.vert_2_index = vert.index
                    self.vert_2_co = Vector((vert.co.x,vert.co.y,vert.co.z))
                    break
            bpy.ops.object.mode_set(mode='EDIT')
            
            if self.vert_2_index == -1:
                #Aggiungo solo i vertici collegati
                self.Vert=[] #Verificare se serve
                bpy.ops.mesh.select_more()
                bpy.ops.object.mode_set(mode='OBJECT')
                for vert in obj.data.vertices:
                    if vert.select:
                        if vert.index != self.vert_1_index:
                            self.Vert.append(vert.index)
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                obj.data.vertices[self.vert_1_index].select=True #Select the original vertex
                obj.data.vertices[self.Vert[0]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            
            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "No active object, could not finish")
            return {'CANCELLED'}

def register():
    bpy.utils.register_class(ModalOperator)


def unregister():
    bpy.utils.unregister_class(ModalOperator)


if __name__ == "__main__":
    register()


#14
Seregost

Seregost

    Moderator

  • Moderators
  • 5617 messaggi
  • LocationTerzo di Aquileia
Funge :smile:

Cercherò di fare dei test più intensivi per vedere se c'è qualcosa che non va o se ci sono dei suggerimenti, comunque mettilo sono vertex specials
Immagine inserita REGOLAMENTO FORUM: !!LEGGERE PLEASE!!
Immagine inserita GUIDA BLENDER 2.5: DOWNLOAD GUIDA ITALIANO
Immagine inserita BLENDER PRINCIPIANTI: GUIDA PER PRINCIPIANTI ASSOLUTI

#15
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Ma sei un missile! :shock:
Allora, ho provato.
Il sistema funziona! Ci sono alcune cose da correggere. Te le segnalo anche se magari le hai già notate.
La cosa forse più grave è che se io lancio il comando e sposto il vertice di un po', poi cambio edge sul quale farlo muovere, il vertice si sposta non dal punto originario, ma da dove era quando ho cambiato edge. Questo non è corretto. Deve sempre tenere come riferimento la retta che passava per il vertice originario e quello secondario che viene cambiato.
Seconda cosa: andando avanti e indietro un po' di volte col mouse portando il vertice ai limiti, dopo un po' il vertice non si muove più ma rimane fermo attaccato all'altro vertice. Non so come mai, sembra che vada fuori scala coi movimenti del mouse.
Passiamo alle piccolezze, che è una: sarebbe bello che quando completo l'operazione mi rimanga selezionato solo il vertice che avevo selezionato inizialmente.

Tutto ciò partendo con un vertice selezionato.

Con due vertici: mi pare che specialmente con alt premuto fa qualche casino. Si blocca, e se lo ripremo riparte.

Comunque un giorno mi spieghi qualcosa di ste robe! Mi piacerebbe riuscire a far qualcosa di scripting! :grin:

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#16
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
sarebbe bello che quando completo l'operazione mi rimanga selezionato solo il vertice che avevo selezionato inizialmente.
Fatto, non ci avevo pensato, dovrebbe rimanere selezionato sia in caso di conferma che di annulla. Lo script corretto è l'ultimo postato


il vertice si sposta non dal punto originario, ma da dove era quando ho cambiato edge

Mi sembrava più corretto così. Sicuro che vuoi tenere sempre come riferimento la posizione originale del punto selezionato?
Domani provo a vedere come sistemarlo, magari, aggiungo un tasto per lasciare le due possibilità (Inizialmente pensavo di fare questo script con 2 righe di codice, guarda cosa è diventato adesso! :mrgreen: )


dopo un po' il vertice non si muove più

Devo verificare perché, anche questo lo controllo domani


Con due vertici: mi pare che specialmente con alt premuto fa qualche casino

Visto ora, non ci avevo fatto caso, credo di sapere il problema. Anche questo domani sera, spero.


Comunque un giorno mi spieghi qualcosa di ste robe! Mi piacerebbe riuscire a far qualcosa di scripting
Pensavo, magari di prendere per esempio, questo script e commentarlo riga per riga? Potrebbe essere un inizio.
Comunque tieni conto che anch'io sono abbastanza un novellino con Python e le API Blender, e quindi non di tutto so il funzionamento :)
Io vengo da Visual Basic quindi sto imparando sia Python che le API. Il tutto utilizzando come editor praticamante Note Pad (in realtà uso Notepad ++), tutta un'altra cosa dell'editor di VB con autocompletametno automatico, controllo della sintassi live e tutte quelle finezze che mamma MIcrosoft offre nei suoi ambienti di sviluppo :wink:

Ciao
VB

#17
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso

Io vengo da Visual Basic

Anche io, ma non penso di essere al tuo livello! :oops:
Se commentassi il codice riga per riga sarebbe già un buon inizio!

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#18
andcamp

andcamp

    Blender Professional

  • Supporter
  • 7657 messaggi

Se commentassi il codice riga per riga sarebbe già un buon inizio!


per cominciare, un po' di cultura, con l'equazione di una retta nello spazio passante per due punti http://www.matematic...a_200804072650/

da cui

def NewCo(v0,v1,t):
    #Equation of the line
    x = v0.x + (v1.x - v0.x) * t
    y = v0.y + (v1.y - v0.y) * t
    z = v0.z + (v1.z - v0.z) * t
    return Vector((x,y,z))

CTRL+SHIFT+B

#19
Lell

Lell

    Blender Professional

  • Members
  • 7541 messaggi
  • Locationprovincia Treviso
Vero, senza un po' di matematica è difficile programmare.

Gallery RENDERS | Gallery MODELLI

 

-> I'm on BLENDER NETWORK ->


Introduzione alla grafica 3D(aggiornata al 30/10/2011)

Mens Sana in Corpore Sano
La verità sta nel mezzo


#20
ValterVB

ValterVB

    Blender Senior

  • Members
  • 542 messaggi
Matematica/geometria....

Vero, senza, sopratutto in casi come questo è un po' difficile :) e non è che sia il mio forte :(

Difatti quello che chiede Lell è un po' più complicato di quel che pensavo, se ho capito bene.
Se mantengo come riferimento la linea fra la posizione del vertice che ho selezionato all'inizio e il vertice di riferimento, nel momento che cambio vertice di riferimento, il vertice che sto spostando salta di colpo sulla nuova "linea" di riferimento: vedere questo video video
E' così che deve lavorare? o si deve muovere su una linea parallella alla linea originale?

Spero di essermi spiegato :roll:

Nel dubbio posto questa nuova versione:

import bpy
from bpy.props import IntProperty, FloatProperty, FloatVectorProperty
from mathutils import Vector

#TODO: disabilitare  l'undo all'inizio e poi riabilitarlo alla fine
#Tenere come riferimento il punto originale non la nuova posizione
#Eventualmente tenere tutte e 2 i modi
#dopo un po' il vertice non si muove più: probabilmente qunado si sovrappongono i 2 vertici


def NewCo(v0,v1,t):
    #Equation of the line
    #Changing t, I have a new point on the line along v0 v1
    x = v0.x + (v1.x - v0.x) * t
    y = v0.y + (v1.y - v0.y) * t
    z = v0.z + (v1.z - v0.z) * t
    return Vector((x,y,z))


class ModalOperator(bpy.types.Operator):
    bl_idname = "vertex.slide"
    bl_label = "Vertex Slide"

    vert_1_index = -1  #Index of the first vertex selected
    vert_1_co = []     #Coordinates of the first vertex selected

    vert_2_index = -1  #Index of the second vertex selected
    vert_2_co = []     #Coordinates of the second vertex selected

    step = 100  #More higher more precisione is the movement
    
    left_alt=False  #Used for toggle from the first and the second vertex
    shift=False     #Used for toggle from/to normal to/from precision
    
    MouseX=0  #Store te x coordinate of the mouse
    MouseY=0  #Store te y coordinate of the mouse
    
    Vert=[]
    SecondVertIndex=0
    
    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':
            if self.vert_2_index != -1:  #Starting with 2 vertex selected
                Vertices = bpy.context.object.data.vertices
                bpy.ops.object.mode_set(mode='OBJECT')
                if self.left_alt:
                    Vertices[self.vert_1_index].co =  NewCo(Vertices[self.vert_1_index].co, Vertices[self.vert_2_index].co,(event.mouse_x-self.MouseX)/self.step)
                else:
                    Vertices[self.vert_2_index].co =  NewCo(Vertices[self.vert_2_index].co, Vertices[self.vert_1_index].co,(event.mouse_x-self.MouseX)/self.step)
                self.MouseX=event.mouse_x
                bpy.ops.object.mode_set(mode='EDIT')
            else: #Starting with 1 vertex selected
                Vertices = bpy.context.object.data.vertices
                bpy.ops.object.mode_set(mode='OBJECT')
                #Vertices[self.vert_1_index].co =  NewCo(Vertices[self.vert_1_index].co, Vertices[self.Vert[self.SecondVertIndex]].co,(event.mouse_x-self.MouseX)/self.step)
                #Per farlo funzionare dovrebbe muoversi in maniera parallela ?
                Vertices[self.vert_1_index].co =  NewCo(self.vert_1_co, Vertices[self.Vert[self.SecondVertIndex]].co,(event.mouse_x-self.MouseX)/self.step)
                bpy.ops.object.mode_set(mode='EDIT')

        if event.type == 'WHEELDOWNMOUSE':
            if self.vert_2_index == -1:  #Starting with 1 vertex selected
                Vertices = bpy.context.object.data.vertices
                self.SecondVertIndex =self.SecondVertIndex+ 1
                if self.SecondVertIndex >= len(self.Vert)-1:
                    self.SecondVertIndex = len(self.Vert)-1
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.Vert[self.SecondVertIndex]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
        
        if event.type == 'WHEELUPMOUSE':
            if self.vert_2_index == -1:
                Vertices = bpy.context.object.data.vertices
                self.SecondVertIndex =self.SecondVertIndex- 1
                if self.SecondVertIndex < 0:
                    self.SecondVertIndex = 0
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.Vert[self.SecondVertIndex]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
        
        elif event.type == 'LEFTMOUSE':
            Vertices = bpy.context.object.data.vertices
            if self.vert_2_index == -1:
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            else:
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.vert_2_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            return {'FINISHED'}

        elif event.type=='LEFT_ALT':
            self.left_alt = not self.left_alt

        elif event.type == 'LEFT_SHIFT':
            if self.step == 100:
                self.step = 1000
            else:
                self.step = 100

        elif event.type in ('RIGHTMOUSE', 'ESC'):  #Restore and exit
            obj = bpy.context.object  #Cancellare
            Vertices = bpy.context.object.data.vertices
            bpy.ops.object.mode_set(mode='OBJECT')
            Vertices[self.vert_1_index].co = self.vert_1_co
            if self.vert_2_index != -1:
                Vertices[self.vert_2_index].co = self.vert_2_co
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                Vertices[self.vert_2_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            else:
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                Vertices[self.vert_1_index].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            bpy.ops.object.mode_set(mode='EDIT')
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        #verificare se serve azzerare le variabili self
        if context.object:
            self._initial_mouse = Vector((event.mouse_x, event.mouse_y, 0.0))
            self.MouseX=event.mouse_x
            self.MouseY=event.mouse_y
            obj = bpy.context.object
            bpy.ops.object.mode_set(mode='OBJECT')
            #Store the original coordinates for Cancel
            for vert in obj.data.vertices:
                if vert.select and self.vert_1_index == -1:
                    self.vert_1_index = vert.index
                    self.vert_1_co = Vector((vert.co.x,vert.co.y,vert.co.z))
                elif vert.select and self.vert_2_index == -1 and vert.index != self.vert_1_index:
                    self.vert_2_index = vert.index
                    self.vert_2_co = Vector((vert.co.x,vert.co.y,vert.co.z))
                    break
            bpy.ops.object.mode_set(mode='EDIT')
            
            if self.vert_2_index == -1:
                #Aggiungo solo i vertici collegati
                self.Vert=[] #Verificare se serve
                bpy.ops.mesh.select_more()
                bpy.ops.object.mode_set(mode='OBJECT')
                for vert in obj.data.vertices:
                    if vert.select:
                        if vert.index != self.vert_1_index:
                            self.Vert.append(vert.index)
                bpy.ops.object.mode_set(mode='EDIT')
                bpy.ops.mesh.select_all(action='DESELECT')
                bpy.ops.object.mode_set(mode='OBJECT')
                obj.data.vertices[self.vert_1_index].select=True #Select the original vertex
                obj.data.vertices[self.Vert[0]].select=True
                bpy.ops.object.mode_set(mode='EDIT')
            
            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "No active object, could not finish")
            return {'CANCELLED'}
    
def register():
    bpy.utils.register_class(ModalOperator)


def unregister():
    bpy.utils.unregister_class(ModalOperator)


if __name__ == "__main__":
    register()





0 utente(i) stanno leggendo questa discussione

0 members, 0 guests, 0 anonymous users