-
NBurn authored
This should take care of most of the class property conversions to use the new annotation format (colon instead of equals) for assignment in 2.80. There may still be a few edge cases that were missed.
NBurn authoredThis should take care of most of the class property conversions to use the new annotation format (colon instead of equals) for assignment in 2.80. There may still be a few edge cases that were missed.
io_import_sound_to_anim.py 85.57 KiB
#!/usr/bin/python3
# To change this template, choose Tools | Templates
# and open the template in the editor.
# ***** GPL LICENSE BLOCK *****
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# All rights reserved.
# ***** GPL LICENSE BLOCK *****
bl_info = {
"name": "Import: Sound to Animation",
"author": "Vlassius",
"version": (0, 70),
"blender": (2, 64, 0),
"location": "Select a object > Object tab > Import Movement From Wav File",
"description": "Extract movement from sound file. "
"See the Object Panel at the end.",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
"Scripts/Import-Export/Import_Movement_From_Audio_File",
"tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
"category": "Import-Export"}
"""
-- Extract movement from sound file, to help in animation - import script --<br>
- NOTES:
- This script takes a wav file and get sound "movement" to help you in sync the movement to words in the wave file. <br>
- Supported Audio: .wav (wave) 8 bits and 16 bits - mono and multichanel file<br>
- At least Blender 2.64.9 is necessary to run this program.
- Curitiba - Brasil
-v 0.70Beta-
Included: SmartRender - Render just the frames that has changes
Included: Options to check SmartRender for Blender Internal Render Engine:LocRotScale, Material, Transp, Mirror
Included: User can Cancel all functions with CANCEL button- Extensive Code and flux change (bugs expected)
Included: User can Cancel all functions with ESC
Inclused: User friendly messages into UI while running (its no more necessary to look at terminal window to most users)
Cleanup: Non Stardard Chars in coments
To Do: Decrease overhead of timer loops
To Do: Try to implement Smart Render for Cycles
-v 0.60Beta-
Included: Option to use just the beat from the audio sound
Included: Option to exclude the beat from the audio sound
Included: More or less sensibility options when using the beat
Included: Audio Channel Select option
-v 0.50Beta-
Included: Auto Adjust Audio Sensity option
Included: 8 bits .wav file support
Recalibrated: Manual audio sense 1
Cosmetic: Many changes in panel and terminal window info
Corrected: Tracker_url
Corrected: a few bytes in Memory Leaks
work around: memory leak in function: bpy.ops.transform.rotate
work around: memory leak in function: bpy.ops.anim.keyframe_insert
-v 0.22Beta-
Included:
Camera Rotation
Empty Location-Rotation-Scale
-v 0.21Beta-
Changed just the meta informations like version and wiki page.
-v 0.20 Beta-
New Panel
-v 0.1.5 Beta-
Change in API-> Properties
Included the button "Get FPS from Scene" due to a problem to get it in the start
Return to Frame 1 after import
Filter .wav type file (by batFINGER)
-v 0.1.4 Beta-
If choose negative in rotation, auto check the rotation negative to Bones
change in register() unregister():
-v 0.1.3 Beta-
File Cleanup
Change to bl_info.
Cosmetic Changes.
Minor change in API in how to define buttons.
Adjust in otimization.
-v 0.1.2 Beta
change in API- Update function bpy.ops.anim.keyframe_insert_menu
-v 0.1.1 Beta
change in API- Update property of window_manager.fileselect_add
-v 0.1.0 Beta
new - Added support to LAMP object
new - improved flow to import
new - check the type of object before show options
bug - option max. and min. values
change- Updated scene properties for changes in property API.
See http://lists.blender.org/pipermail/bf-committers/2010-September/028654.html
new flow: 1) Process the sound file 2) Show Button to import key frames
- v0.0.4 ALPHA
new - Added destructive optimizer option - LostLestSignificativeDigit lost/total -> 10/255 default
new - Visual Graph to samples
new - Option to just process audio file and do not import - this is to help adjust the audio values
new - Get and show automatically the FPS (in proper field) information taking the information from scene
bug- Display sensitivity +1
bug - Corrected location of the script in description
- v0.0.3
Main change: Corrected to work INSIDE dir /install/linux2/2.53/scripts/addons
Corrected position of label "Rotation Negative"
Added correct way to deal with paths in Python os.path.join - os.path.normpath
- v0.0.2
Corrected initial error (Register() function)
Corrected some labels R. S. L.
Turned off "object field" for now
Changed target default to Z location
- v0.0.1
Initial version
Credit to:
Vlassius
- http://vlassius.com.br
- vlassius@vlassius.com.br
- Curitiba - Brasil
"""
import bpy
from bpy.props import *
#from io_utils import ImportHelper
import wave
#para deixar global
def _Interna_Globals(BytesDadosTotProcess, context):
global array
global arrayAutoSense
array= bytearray(BytesDadosTotProcess) # cria array
arrayAutoSense= bytearray((BytesDadosTotProcess)*2) # cria array para AutoAudioSense
context.scene.imp_sound_to_anim.bArrayCriado=True
#
#==================================================================================================
# BLENDER UI Panel
#==================================================================================================
#
class VIEW3D_PT_CustomMenuPanel(bpy.types.Panel):
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_label = "Import Movement From Wav File"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
b=bpy.context.active_object.type=='EMPTY' or bpy.context.active_object.type=='ARMATURE' or \
bpy.context.active_object.type=='MESH' or \
bpy.context.active_object.type=='CAMERA' or \
bpy.context.active_object.type=='LAMP'
if not b:
row=layout.row()
row.label(text="The Selected Object is: type \"" + bpy.context.active_object.type + \
"\", and it is not supported.")
row=layout.row()
row.label(text="Supported Object are Type: Armature, Mesh, Camera and Lamp")
row=layout.row()
else:
#print(context.scene.imp_sound_to_anim.bTypeImport)
if context.scene.imp_sound_to_anim.bTypeImport == 0:
#mount panel to Direct animation
row=layout.row()
layout.operator("import.sound_animation_botao_udirect")
# monta as telas quando está rodando
elif context.scene.imp_sound_to_anim.Working!="": #its running
row=layout.row()
row=layout.row()
if context.scene.imp_sound_to_anim.Working== "CheckSmartRender":
#context.scene.imp_sound_to_anim.Info_check_smartrender=
row=layout.row()
row.label(text="Checking for Smart Render...")
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_check_smartrender)
row=layout.row()
elif context.scene.imp_sound_to_anim.Working== "SmartRender":
#context.scene.imp_sound_to_anim.Info_check_smartrender=
row=layout.row()
row.label(text="Processing Smart Render...")
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_check_smartrender)
row=layout.row()
elif context.scene.imp_sound_to_anim.Working== "ProcessaSom":
#context.scene.imp_sound_to_anim.Info_Import=
row=layout.row()
row.label(text="Processing Sound File...")
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_Import)
elif context.scene.imp_sound_to_anim.Working== "wavimport":
#context.scene.imp_sound_to_anim.Info_Import=
row=layout.row()
row.label(text="Importing Keys...")
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_Import)
row=layout.row()
# botao cancel
layout.operator(OBJECT_OT_Botao_Cancel.bl_idname)
row=layout.row()
elif context.scene.imp_sound_to_anim.bTypeImport == 1:
row=layout.row()
row.label(text="1)Click button \"Process Wav\",")
row=layout.row()
row.label(text="2)Click Button \"Import Key Frames\",")
row=layout.row()
row.label(text="Run the animation (alt A) and Enjoy!")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"action_auto_audio_sense")
row=layout.row()
if context.scene.imp_sound_to_anim.action_auto_audio_sense == 0: # se auto audio sense desligado
row.prop(context.scene.imp_sound_to_anim,"audio_sense")
row=layout.row()
else: #somente se autosense ligado
if context.scene.imp_sound_to_anim.remove_beat == 0 :
row.prop(context.scene.imp_sound_to_anim,"use_just_beat")
if context.scene.imp_sound_to_anim.use_just_beat == 0:
row.prop(context.scene.imp_sound_to_anim,"remove_beat")
if context.scene.imp_sound_to_anim.use_just_beat or context.scene.imp_sound_to_anim.remove_beat:
if not context.scene.imp_sound_to_anim.beat_less_sensible and not context.scene.imp_sound_to_anim.beat_more_sensible:
row=layout.row()
if context.scene.imp_sound_to_anim.beat_less_sensible ==0:
row.prop(context.scene.imp_sound_to_anim,"beat_more_sensible")
if context.scene.imp_sound_to_anim.beat_more_sensible ==0:
row.prop(context.scene.imp_sound_to_anim,"beat_less_sensible")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"action_per_second")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"action_escale")
#row=layout.row()
row.label(text="Result from 0 to " + str(round(255/context.scene.imp_sound_to_anim.action_escale,4)) + "")
row=layout.row()
row.label(text="Property to Change:")
row.prop(context.scene.imp_sound_to_anim,"import_type")
#coluna
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"import_where1")
row.prop(context.scene.imp_sound_to_anim,"import_where2")
row.prop(context.scene.imp_sound_to_anim,"import_where3")
row=layout.row()
row.label(text='Optional Configurations:')
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"frames_per_second")
row=layout.row()
#coluna
column= layout.column()
split=column.split(percentage=0.5)
col=split.column()
row=col.row()
row.prop(context.scene.imp_sound_to_anim,"frames_initial")
row=col.row()
row.prop(context.scene.imp_sound_to_anim,"action_min_value")
col=split.column()
row=col.row()
row.prop(context.scene.imp_sound_to_anim,"optimization_destructive")
row=col.row()
row.prop(context.scene.imp_sound_to_anim,"action_max_value")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"action_offset_x")
row.prop(context.scene.imp_sound_to_anim,"action_offset_y")
row.prop(context.scene.imp_sound_to_anim,"action_offset_z")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"audio_channel_select")
row.prop(context.scene.imp_sound_to_anim,"action_valor_igual")
#operator button
#OBJECT_OT_Botao_Go => Botao_GO
row=layout.row()
layout.operator(OBJECT_OT_Botao_Go.bl_idname)
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_Import)
# preciso garantir a existencia do array porque o Blender salva no arquivo como existente sem o array existir
try:
array
except NameError:
nada=0 #dummy
else:
if context.scene.imp_sound_to_anim.bArrayCriado:
layout.operator(OBJECT_OT_Botao_Import.bl_idname)
row=layout.row()
#Layout SmartRender, somente para Blender_render
if bpy.context.scene.render.engine == "BLENDER_RENDER":
row=layout.row()
row.label(text="----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------")
row=layout.row()
if context.scene.imp_sound_to_anim.Info_check_smartrender!= "":
row=layout.row()
row.label(text=context.scene.imp_sound_to_anim.Info_check_smartrender)
row=layout.row()
row.operator(OBJECT_OT_Botao_Check_SmartRender.bl_idname)
if context.scene.imp_sound_to_anim.Info_check_smartrender!= "":
row.operator(OBJECT_OT_Botao_SmartRender.bl_idname)
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"check_smartrender_loc_rot_sc")
row.prop(context.scene.imp_sound_to_anim,"check_smartrender_material_basic")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"check_smartrender_material_transparence")
row.prop(context.scene.imp_sound_to_anim,"check_smartrender_material_mirror")
#-----------------------------
#Use Driver
#-----------------------------
if context.scene.imp_sound_to_anim.bTypeImport == 2:
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"audio_sense")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"frames_per_second")
row=layout.row()
row.prop(context.scene.imp_sound_to_anim,"action_per_second")
row=layout.row()
layout.operator(ImportWavFile.bl_idname)
#
#==================================================================================================
# BLENDER UI PropertyGroup
#==================================================================================================
#
class ImpSoundtoAnim(bpy.types.PropertyGroup):
#Array created
bArrayCriado: IntProperty(name="",
description="Avisa que rodou process de som",
default=0)
#Script Running
Working: StringProperty(name="",
description="Script esta trabalhando",
maxlen= 1024,
default="")
#Nome do objeto
Info_Import: StringProperty(name="",
description="Info about Import",
maxlen= 1024,
default= "")#this set the initial text
#Mensagem Smart Render
Info_check_smartrender: StringProperty(name="",
description="Smart Render Message",
maxlen= 1024,
default= "")#this set the initial text
#iAudioSensib=0 #sensibilidade volume do audio 0 a 5. Quanto maior, mais sensibilidade
audio_sense: IntProperty(name="Audio Sens",
description="Audio Sensibility.",
min=1,
max=6,
step=1,
default= 1)
#iFramesPorSeg=15 #Frames por segundo para key frame
#fps= (bpy.types.Scene) bpy.context.scene.render.fps
frames_per_second: IntProperty(name="#Frames/s",
description="Frames you want per second. Better match your set up in Blender scene.",
min=1,
max=120,
step=1)
#iMovPorSeg=1 #Sensibilidade de movimento. 3= 3 movimentos por segundo
action_per_second: IntProperty(name="Act/s",
description="Actions per second. From 1 to #Frames/s",
min=1,
max=120,
step=1,
default= 4)#this set the initial text
#iDivScala=200
#scala do valor do movimento. [se =1 - 0 a 255 ] [se=255 - 0,00000 a 1,00000] [se=1000 - 0 a 0.255]
action_escale: IntProperty(name="Scale",
description="Scale the result values. See the text at right side of the field",
min=1,
max=99999,
step=100,
default= 100)#this set the initial text
#iMaxValue=255
action_max_value: IntProperty(name="Clip Max",
description="Set the max value (clip higher values).",
min=1,
max=255,
step=1,
default= 255)#this set the initial text
#iMinValue=0
action_min_value: IntProperty(name="Clip Min",
description="Set the min value. (clip lower values)",
min=0,
max=255,
step=1,
default= 0)#this set the initial text
#iStartFrame=0#
frames_initial: IntProperty(name="Frame Ini",
description="Where to start to put the computed values.",
min=0,
max=999999999,
step=1,
default= 0)
audio_channel_select: IntProperty(name="Audio Channel",
description="Choose the audio channel to use",
min=1,
max=10,
step=1,
default= 1)
action_offset_x: FloatProperty(name="XOffset",
description="Offset X Values",
min=-999999,
max=999999,
step=1,
default= 0)
action_offset_y: FloatProperty(name="YOffset",
description="Offset Y Values",
min=-999999,
max=999999,
step=1,
default= 0)
action_offset_z: FloatProperty(name="ZOffset",
description="Offset Z Values",
min=-999999,
max=999999,
step=1,
default= 0)
import_type: EnumProperty(items=(('imp_t_Scale', "Scale", "Apply to Scale"),
('imp_t_Rotation', "Rotation", "Apply to Rotation"),
('imp_t_Location', "Location", "Apply to Location")
),
name="",
description= "Property to Import Values",
default='imp_t_Location')
import_where1: EnumProperty(items=(('imp_w_-z', "-z", "Apply to -z"),
('imp_w_-y', "-y", "Apply to -y"),
('imp_w_-x', "-x", "Apply to -x"),
('imp_w_z', "z", "Apply to z"),
('imp_w_y', "y", "Apply to y"),
('imp_w_x', "x", "Apply to x")
),
name="",
description= "Where to Import",
default='imp_w_z')
import_where2: EnumProperty(items=(('imp_w_none', "None", ""),
('imp_w_-z', "-z", "Apply to -z"),
('imp_w_-y', "-y", "Apply to -y"),
('imp_w_-x', "-x", "Apply to -x"),
('imp_w_z', "z", "Apply to z"),
('imp_w_y', "y", "Apply to y"),
('imp_w_x', "x", "Apply to x")
),
name="",
description= "Where to Import",
default='imp_w_none')
import_where3: EnumProperty(items=(('imp_w_none', "None", ""),
('imp_w_-z', "-z", "Apply to -z"),
('imp_w_-y', "-y", "Apply to -y"),
('imp_w_-x', "-x", "Apply to -x"),
('imp_w_z', "z", "Apply to z"),
('imp_w_y', "y", "Apply to y"),
('imp_w_x', "x", "Apply to x")
),
name="",
description= "Where to Import",
default='imp_w_none')
#========== Propriedades boolean =============#
# INVERTIDO!!! bNaoValorIgual=True # nao deixa repetir valores INVERTIDO!!!
action_valor_igual: BoolProperty(name="Hard Transition",
description="Use to movements like a mouth, to a arm movement, maybe you will not use this.",
default=1)
action_auto_audio_sense: BoolProperty(name="Auto Audio Sensitivity",
description="Try to discover best audio scale. ",
default=1)
use_just_beat:BoolProperty(name="Just Use The Beat",
description="Try to use just the beat to extract movement.",
default=0)
remove_beat:BoolProperty(name="Remove The Beat",
description="Try to remove the beat to extract movement.",
default=0)
beat_more_sensible:BoolProperty(name="More Sensible",
description="Try To be more sensible about the beat.",
default=0)
beat_less_sensible:BoolProperty(name="Less Sensible",
description="Try to be less sensible about the beat.",
default=0)
check_smartrender_loc_rot_sc:BoolProperty(name="Loc Rot Scale",
description="Find changes in Location, Rotation and Scale Frame by Frame.",
default=1)
check_smartrender_material_basic:BoolProperty(name="Basic Material",
description="Find changes in basic material settings Frame by Frame.",
default=1)
check_smartrender_material_transparence:BoolProperty(name="Material Transparence",
description="Find changes in material transparence settings Frame by Frame.",
default=0)
check_smartrender_material_mirror:BoolProperty(name="Material Mirror",
description="Find changes in material mirror settings Frame by Frame.",
default=0)
timer_reset_func:BoolProperty(name="Reset Counters",
description="Reset Counters after stop",
default=0)
cancel_button_hit:BoolProperty(name="Cancel Hit",
description="Cancel Hit",
default=0)
# Optimization
optimization_destructive: IntProperty(name="Optimization",
description="Hi value = Hi optimization -> Hi loss of information.",
min=0,
max=254,
step=10,
default= 10)
# import as driver or direct NOT IN USE!!
# not defined
# Direct=1
# Driver=2
bTypeImport: IntProperty(name="",
description="Import Direct or Driver",
default=0)
# globais do dialog open wave
filter_glob: StringProperty(default="*.wav", options={'HIDDEN'})
path: StringProperty(name="File Path", description="Filepath used for importing the WAV file", \
maxlen= 1024, default= "")
filename: StringProperty(name="File Name", description="Name of the file")
directory: StringProperty(name="Directory", description="Directory of the file")
from bpy.props import *
def WavFileImport(self, context):
self.layout.operator(ImportWavFile.bl_idname, text="Import a wav file", icon='PLUGIN')
#
#==================================================================================================
# Use Direct
#==================================================================================================
#
class OBJECT_OT_Botao_uDirect(bpy.types.Operator):
'''Import as Direct Animation'''
bl_idname = "import.sound_animation_botao_udirect"
bl_label = "Direct to a Property"
def execute(self, context):
context.scene.imp_sound_to_anim.bTypeImport= 1
if context.scene.imp_sound_to_anim.frames_per_second == 0:
context.scene.imp_sound_to_anim.frames_per_second= bpy.context.scene.render.fps
return{'FINISHED'}
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
#
#==================================================================================================
# Button - Import
#==================================================================================================
#
class OBJECT_OT_Botao_Import(bpy.types.Operator):
'''Import Key Frames to Blender'''
bl_idname = "import.sound_animation_botao_import"
bl_label = "Import Key Frames"
RunFrom=0
iSumImportFrames=0
iSumOptimizerP1=0
iSumOptimizerP2=0
iSumOptimizerP3=0
def wavimport(context, loop):
obi=OBJECT_OT_Botao_Import
# para de entrar no timer
context.scene.imp_sound_to_anim.Working=""
#reseta contadores caso seja pedido
if context.scene.imp_sound_to_anim.timer_reset_func:
obi.RunFrom=0
obi.iSumOptimizerP1=0
obi.iSumOptimizerP2=0
obi.iSumOptimizerP3=0
obi.iSumImportFrames=0
context.scene.imp_sound_to_anim.timer_reset_func=False
#limita o loop se estiver no fim
tot=len(array)-1
if obi.RunFrom+loop > tot:
loop= tot - obi.RunFrom
#scala do valor do movimento. [se =1 - 0 a 255 ] [se=255 - 0,00000 a 1,00000] [se=1000 - 0 a 0.255]
iDivScala= int(context.scene.imp_sound_to_anim.action_escale)
# nao deixa repetir valores
bNaoValorIgual=True
if context.scene.imp_sound_to_anim.action_valor_igual: bNaoValorIgual= False
# inicia no inicio pedido pelo usuario mais ponteiro RunFrom
iStartFrame= int(context.scene.imp_sound_to_anim.frames_initial) + obi.RunFrom
iMaxValue= context.scene.imp_sound_to_anim.action_max_value
iMinValue= context.scene.imp_sound_to_anim.action_min_value
bEscala=bRotacao=bEixo=False
if context.scene.imp_sound_to_anim.import_type=='imp_t_Scale':
bEscala=True;
if context.scene.imp_sound_to_anim.import_type=='imp_t_Rotation':
bRotacao=True;
if context.scene.imp_sound_to_anim.import_type=='imp_t_Location':
bEixo=True;
# atencao, nao eh boolean
iEixoXneg= iEixoYneg= iEixoZneg=1
# atencao, nao eh boolean
iRotationNeg=1
# atencao, nao eh boolean
iEscalaYneg= iEscalaZneg= iEscalaXneg=1
bEixoX=bEixoY=bEixoZ=bEscalaX=bEscalaY=bEscalaZ=bRotationX=bRotationY=bRotationZ=False
# LOCAL 1
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_x':
bEixoX=True
bEscalaX=True
bRotationX=True
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_y':
bEixoY=True
bEscalaY=True
bRotationY=True
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_-x':
bEixoX=True
bEscalaX=True
bRotationX=True
iEixoXneg=-1
iEscalaXneg=-1
iRotationNeg=-1
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_-y':
bEixoY=True
bEscalaY=True
bRotationY=True
iEixoYneg=-1
iRotationNeg=-1
iEscalaYneg=-1
if context.scene.imp_sound_to_anim.import_where1== 'imp_w_-z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
iEixoZneg=-1
iRotationNeg=-1
iEscalaZneg=-1
# LOCAL 2
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_x':
bEixoX=True
bEscalaX=True
bRotationX=True
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_y':
bEixoY=True
bEscalaY=True
bRotationY=True
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_-x':
bEixoX=True
bEscalaX=True
bRotationX=True
iEixoXneg=-1
iEscalaXneg=-1
iRotationNeg=-1
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_-y':
bEixoY=True
bEscalaY=True
bRotationY=True
iEixoYneg=-1
iRotationNeg=-1
iEscalaYneg=-1
if context.scene.imp_sound_to_anim.import_where2== 'imp_w_-z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
iEixoZneg=-1
iRotationNeg=-1
iEscalaZneg=-1
# LOCAL 3
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_x':
bEixoX=True
bEscalaX=True
bRotationX=True
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_y':
bEixoY=True
bEscalaY=True
bRotationY=True
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_-x':
bEixoX=True
bEscalaX=True
bRotationX=True
iEixoXneg=-1
iEscalaXneg=-1
iRotationNeg=-1
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_-y':
bEixoY=True
bEscalaY=True
bRotationY=True
iEixoYneg=-1
iRotationNeg=-1
iEscalaYneg=-1
if context.scene.imp_sound_to_anim.import_where3== 'imp_w_-z':
bEixoZ=True
bEscalaZ=True
bRotationZ=True
iEixoZneg=-1
iRotationNeg=-1
iEscalaZneg=-1
iMinBaseX=iMinScaleBaseX=context.scene.imp_sound_to_anim.action_offset_x
iMinBaseY=iMinScaleBaseY=context.scene.imp_sound_to_anim.action_offset_y
iMinBaseZ=iMinScaleBaseZ=context.scene.imp_sound_to_anim.action_offset_z
#escala inicia com 1 e nao com zero
iRotationAxisBaseX=context.scene.imp_sound_to_anim.action_offset_x +1
iRotationAxisBaseY=context.scene.imp_sound_to_anim.action_offset_y +1
iRotationAxisBaseZ=context.scene.imp_sound_to_anim.action_offset_z +1
#Added destructive optimizer option - LostLestSignificativeDigit lost/total
iDestructiveOptimizer=context.scene.imp_sound_to_anim.optimization_destructive
#limita ou nao o valor - velocidade
bLimitValue=False
if iMinValue<0: iMinValue=0
if iMaxValue>255: iMaxValue=255
if iMinValue>255: iMinValue=255
if iMaxValue<0: iMaxValue=0
if iMinValue!= 0: bLimitValue= True
if iMaxValue!= 255: bLimitValue= True
if obi.RunFrom==0:
print('')
print("================================================================")
from time import strftime
print(strftime("Start Import: %H:%M:%S"))
print("================================================================")
print('')
ilocationXAnt=0
ilocationYAnt=0
ilocationZAnt=0
iscaleXAnt=0
iscaleYAnt=0
iscaleZAnt=0
iRotateValAnt=0
# variavel global _Interna_Globals
if context.scene.imp_sound_to_anim.bArrayCriado:
for i in range(loop):
ival=array[i+obi.RunFrom]/iDivScala
#valor pequeno demais, vai dar zero na hora de aplicar
if ival < 0.001:
array[i+obi.RunFrom]=0
ival=0
# to increase performance and legibility
arrayI= array[i+obi.RunFrom]
arrayIP1= array[i+1+obi.RunFrom]
arrayIL1= array[i-1+obi.RunFrom]
# opcao de NAO colocar valores iguais sequenciais
if i>0 and bNaoValorIgual and arrayIL1== arrayI:
print("Importing Blender Frame: "+str(i+obi.RunFrom+1)+"\tof "+str(len(array)-1) + \
"\t(skipped by optimizer)")
obi.iSumOptimizerP3+=1
else:
# otimizacao - nao preciso mais que 2 valores iguais.
# pular key frame intermediario - Ex b, a, -, -, -, a
# tambem otimiza pelo otimizador com perda
# valor atual == anterior e posterior -> pula
if i>0 and i< len(array)-1 and abs(arrayI - arrayIL1)<=iDestructiveOptimizer and \
abs(arrayI - arrayIP1)<=iDestructiveOptimizer:
print("Importing Blender Frame: "+str(i+obi.RunFrom+1)+"\tof "+str(len(array)-1) + \
"\t(skipped by optimizer)")
if iDestructiveOptimizer>0 and arrayI != arrayIL1 or arrayI != arrayIP1:
obi.iSumOptimizerP1+=1
else: obi.iSumOptimizerP2+=1
else:
if bLimitValue:
if arrayI > iMaxValue: array[i+obi.RunFrom]=iMaxValue
if arrayI < iMinValue: array[i+obi.RunFrom]=iMinValue
ival=array[i+obi.RunFrom]/iDivScala
#passa para float com somente 3 digitos caso seja float
m_ival=ival*1000
if int(m_ival) != m_ival:
ival= int(m_ival)
ival = ival /1000
bpy.context.scene.frame_current = i+iStartFrame
#precisa fazer objeto ativo
if bpy.context.active_object.type=='MESH' or bpy.context.active_object.type=='CAMERA' or \
bpy.context.active_object.type=='EMPTY':
if bEixo:
if bEixoX: bpy.context.active_object.location.x = ival*iEixoXneg+iMinBaseX
if bEixoY: bpy.context.active_object.location.y = ival*iEixoYneg+iMinBaseY
if bEixoZ: bpy.context.active_object.location.z = ival*iEixoZneg+iMinBaseZ
if bEscala:
if bEscalaX: bpy.context.active_object.scale.x = ival*iEscalaXneg+iMinScaleBaseX
if bEscalaY: bpy.context.active_object.scale.y = ival*iEscalaYneg+iMinScaleBaseY
if bEscalaZ: bpy.context.active_object.scale.z = ival*iEscalaZneg+iMinScaleBaseZ
# 'ARMATURE' or ('MESH' and bRotacao) or ('CAMERA' and bRotacao) or 'LAMP' or 'EMPTY' and bRotacao)
if bpy.context.active_object.type=='ARMATURE' or (bpy.context.active_object.type=='MESH' and bRotacao) or \
(bpy.context.active_object.type=='CAMERA' and bRotacao) or \
bpy.context.active_object.type=='LAMP' or \
(bpy.context.active_object.type=='EMPTY' and bRotacao):
#=========== BONE ===========#
if bpy.context.active_object.type=='ARMATURE': #precisa ser objeto ativo. Nao achei como passar para editmode
if bpy.context.mode!= 'POSE': #posemode
bpy.ops.object.posemode_toggle()
#============= ALL ===========#
if bEixo:
if ilocationXAnt!=0 or ilocationYAnt!=0 or ilocationZAnt!=0:
bpy.ops.transform.translate(value=(ilocationXAnt*-1, ilocationYAnt*-1, \
ilocationZAnt*-1), constraint_axis=(bEixoX, bEixoY,bEixoZ), \
constraint_orientation='GLOBAL', mirror=False, \
proportional='DISABLED', proportional_edit_falloff='SMOOTH', \
proportional_size=1, snap=False, \
snap_target='CLOSEST', snap_point=(0, 0, 0), \
snap_align=False, snap_normal=(0, 0, 0), \
release_confirm=False)
ilocationX=ilocationY=ilocationZ=0
if bEixoX: ilocationX = ival*iEixoXneg+iMinBaseX
if bEixoY: ilocationY = ival*iEixoYneg+iMinBaseY
if bEixoZ: ilocationZ = ival*iEixoZneg+iMinBaseZ
bpy.ops.transform.translate(value=(ilocationX, ilocationY, \
ilocationZ), constraint_axis=(bEixoX, bEixoY,bEixoZ), \
constraint_orientation='GLOBAL', mirror=False, \
proportional='DISABLED', proportional_edit_falloff='SMOOTH', \
proportional_size=1, snap=False, \
snap_target='CLOSEST', snap_point=(0, 0, 0), snap_align=False, \
snap_normal=(0, 0, 0), release_confirm=False)
ilocationXAnt= ilocationX
ilocationYAnt= ilocationY
ilocationZAnt= ilocationZ
if bEscala:
if iscaleXAnt!=0 or iscaleYAnt!=0 or iscaleZAnt!=0:
tmpscaleXAnt=0
tmpscaleYAnt=0
tmpscaleZAnt=0
if iscaleXAnt: tmpscaleXAnt=1/iscaleXAnt
if iscaleYAnt: tmpscaleYAnt=1/iscaleYAnt
if iscaleZAnt: tmpscaleZAnt=1/iscaleZAnt
bpy.ops.transform.resize(value=(tmpscaleXAnt, tmpscaleYAnt, \
tmpscaleZAnt ), constraint_axis=(False, False, False), \
constraint_orientation='GLOBAL', mirror=False, \
proportional='DISABLED', proportional_edit_falloff='SMOOTH', \
proportional_size=1, snap=False, snap_target='CLOSEST', \
snap_point=(0, 0, 0), snap_align=False, \
snap_normal=(0, 0, 0), release_confirm=False)
iscaleX=iscaleY=iscaleZ=0
if bEscalaX: iscaleX = ival*iEscalaXneg+iMinScaleBaseX
if bEscalaY: iscaleY = ival*iEscalaYneg+iMinScaleBaseY
if bEscalaZ: iscaleZ = ival*iEscalaZneg+iMinScaleBaseZ
bpy.ops.transform.resize(value=(iscaleX, iscaleY, \
iscaleZ), constraint_axis=(False, False, False), \
constraint_orientation='GLOBAL', mirror=False, \
proportional='DISABLED', proportional_edit_falloff='SMOOTH', \
proportional_size=1, snap=False, \
snap_target='CLOSEST', snap_point=(0, 0, 0), \
snap_align=False, snap_normal=(0, 0, 0), \
release_confirm=False)
iscaleXAnt= iscaleX
iscaleYAnt= iscaleY
iscaleZAnt= iscaleZ
if bRotacao:
if iRotateValAnt!=0:
bpy.context.active_object.rotation_euler= ((iRotateValAnt*-1)+ iRotationAxisBaseX) *bRotationX , \
((iRotateValAnt*-1)+ iRotationAxisBaseY) *bRotationY , \
((iRotateValAnt*-1)+ iRotationAxisBaseZ) *bRotationZ
bpy.context.active_object.rotation_euler= ((ival*iRotationNeg)+ iRotationAxisBaseX) * bRotationX, \
((ival*iRotationNeg)+ iRotationAxisBaseY) * bRotationY, \
((ival*iRotationNeg)+ iRotationAxisBaseZ) * bRotationZ
iRotateValAnt= ival*iRotationNeg
ob = bpy.context.active_object
if bEixo:
ob.keyframe_insert(data_path="location")
if bRotacao:
ob.keyframe_insert(data_path="rotation_euler")
if bEscala:
ob.keyframe_insert(data_path="scale")
print("Importing Blender Frame: "+str(i+obi.RunFrom+1)+"\tof "+str(len(array)-1) + "\tValue: "+ str(ival))
obi.iSumImportFrames+=1
# Fim do ELSE otimizador
# Fim bNaoValorIgual
if obi.RunFrom>= tot:
bpy.context.scene.frame_current = 1
context.scene.imp_sound_to_anim.Info_Import="Done. Imported " + str(obi.iSumImportFrames) + " Frames"
from time import strftime
print('')
print("================================================================")
print("Imported: " +str(obi.iSumImportFrames) + " Key Frames")
print("Optimizer Pass 1 prepared to optimize: " +str(obi.iSumOptimizerP1) + " blocks of Frames")
print("Optimizer Pass 2 has optimized: " +str(obi.iSumOptimizerP2) + " Frames")
print("Optimizer Pass 3 has optimized: " +str(obi.iSumOptimizerP3) + " Frames")
print("Optimizer has optimized: " +str(obi.iSumOptimizerP1 + obi.iSumOptimizerP2 + obi.iSumOptimizerP3) + " Frames")
print(strftime("End Import: %H:%M:%S - by Vlassius"))
print("================================================================")
print('')
obi.RunFrom=0
obi.iSumImportFrames=0
obi.iSumOptimizerP1=0
obi.iSumOptimizerP2=0
obi.iSumOptimizerP3=0
return obi.RunFrom
else:
obi.RunFrom+= loop
context.scene.imp_sound_to_anim.Info_Import="Processing Frame " + str(obi.RunFrom+loop) + \
" of " + str(tot-1) + " Frames"
return obi.RunFrom
def execute(self, context):
#wavimport(context)
#return{'FINISHED'}
context.scene.imp_sound_to_anim.Working= "wavimport"
bpy.ops.wm.modal_timer_operator()
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
#
#==================================================================================================
# Button - Sound Process
#==================================================================================================
#
class OBJECT_OT_Botao_Go(bpy.types.Operator):
''''''
bl_idname = "import.sound_animation_botao_go"
# change in API
bl_description = "Process a .wav file, take movement from the sound and import to the scene as Key"
bl_label = "Process Wav"
filter_glob = StringProperty(default="*.wav", options={'HIDDEN'})
path = StringProperty(name="File Path", description="Filepath used for importing the WAV file", \
maxlen= 1024, default= "")
filename = StringProperty(name="File Name", description="Name of the file")
directory = StringProperty(name="Directory", description="Directory of the file")
RunFrom=0
Wave_read=0
MaxAudio=0
def SoundConv(File, DivSens, Sensibil, Resol, context, bAutoSense, bRemoveBeat, bUseBeat, bMoreSensible, \
bLessSensible, AudioChannel, loop):
obg= OBJECT_OT_Botao_Go
#reseta contadores caso seja pedido
if context.scene.imp_sound_to_anim.timer_reset_func:
obc.RunFrom=0
Wave_read=0
MaxAudio=0
context.scene.imp_sound_to_anim.timer_reset_func=False
#abre arquivo se primeira rodada
if obg.RunFrom==0:
try:
obg.Wave_read= wave.open(File, 'rb')
except IOError as e:
print("File Open Error: ", e)
return False
NumCh= obg.Wave_read.getnchannels()
SampW= obg.Wave_read.getsampwidth() # 8, 16, 24 32 bits
FrameR= obg.Wave_read.getframerate()
NumFr= obg.Wave_read.getnframes()
ChkCompr= obg.Wave_read.getcomptype()
if ChkCompr != "NONE":
print('Sorry, this compressed Format is NOT Supported ', ChkCompr)
context.scene.imp_sound_to_anim.Info_Import= "Sorry, this compressed Format is NOT Supported "
return False
if SampW > 2:
context.scene.imp_sound_to_anim.Info_Import= "Sorry, supported .wav files 8 and 16 bits only"
print('Sorry, supported .wav files 8 and 16 bits only')
return False
context.scene.imp_sound_to_anim.Info_Import=""
# controla numero do canal
if AudioChannel > NumCh:
if obg.RunFrom==0:
print("Channel number " + str(AudioChannel) + " is selected but this audio file has just " + \
str(NumCh) + " channels, so selecting channel " \
+ str(NumCh) + "!")
AudioChannel = NumCh
# apenas para por na tela
tmpAudioChannel= AudioChannel
#used in index sum to find the channe, adjust to first byte sample index
AudioChannel -= 1
# se dois canais, AudioChannel=4 porque sao 4 bytes
if SampW ==2: AudioChannel*=2
# usado para achar contorno da onda - achando picos
# numero de audio frames para cada video frame
BytesResol= int(FrameR/Resol)
# com 8 bits/S - razao Sample/s por resolucao
# tamanho do array
BytesDadosTotProcess= NumFr // BytesResol
if obg.RunFrom==0: # primeira rodada
# inicia array
_Interna_Globals(BytesDadosTotProcess, context)
print('')
print("================================================================")
from time import strftime
print(strftime("Go! %H:%M:%S"))
print("================================================================")
print('')
print('Total Audio Time: \t ' + str(NumFr//FrameR) + 's (' + str(NumFr//FrameR//60) + 'min)')
print('Total # Interactions: \t', BytesDadosTotProcess)
print('Total Audio Frames: \t', NumFr)
print('Frames/s: \t\t ' + str(FrameR))
print('# Chanels in File: \t', NumCh)
print('Channel to use:\t\t', tmpAudioChannel)
print('Bit/Sample/Chanel: \t ' + str(SampW*8))
print('# Frames/Act: \t\t', DivSens)
if bAutoSense==0:
print('Audio Sensitivity: \t', Sensibil+1)
else:
print('Using Auto Audio Sentivity. This is pass 1 of 2.')
print('')
print ("Sample->[value]\tAudio Frame # \t\t[Graph Value]")
if obg.RunFrom==0 and bAutoSense!=0:
Sensibil=0 # if auto sense, Sensibil must be zero here
obg.MaxAudio=0 # valor maximo de audio encontrado
# verifica limite total do audio
looptot= int(BytesDadosTotProcess // DivSens)
if obg.RunFrom+loop > looptot:
loop= looptot-obg.RunFrom
j=0 # usado de indice
# laco total leitura bytes
# armazena dado de pico
for jj in range(loop):
# caso de 2 canais (esterio)
# uso apenas 2 bytes em 16 bits, ie, apenas canal esquerdo
# [0] e [1] para CH L
# [2] e [3] para CH R and so on
# mono:1 byte to 8 bits, 2 bytes to 16 bits
# sterio: 2 byte to 8 bits, 4 bytes to 16 bits
ValorPico=0
# leio o numero de frames de audio para cada frame de video, valor em torno de 1000
for i in range(BytesResol):
#loop exterior copia DivSens frames a cada frame calculado
frame = obg.Wave_read.readframes(DivSens)
if len(frame)==0: break
if bAutoSense==0: # AutoAudioSense Desligado
if SampW ==1:
if Sensibil ==5:
frame0= frame[AudioChannel] << 6 & 255
elif Sensibil ==4:
frame0= frame[AudioChannel] << 5 & 255
elif Sensibil ==3:
frame0= frame[AudioChannel] << 4 & 255
elif Sensibil ==2:
frame0= frame[AudioChannel] << 3 & 255
elif Sensibil ==1:
frame0= frame[AudioChannel] << 2 & 255
elif Sensibil ==0:
frame0= frame[AudioChannel]
if frame0> ValorPico:
ValorPico= frame0
if SampW ==2: # frame[0] baixa frame[1] ALTA BIT 1 TEM SINAL!
if frame[1+AudioChannel] <127: # se bit1 =0, usa o valor - se bit1=1 quer dizer numero negativo
if Sensibil ==0:
frame0= frame[1+AudioChannel]
elif Sensibil ==4:
frame0= ((frame[AudioChannel] & 0b11111100) >> 2) | ((frame[1+AudioChannel] & 0b00000011) << 6)
elif Sensibil ==3:
frame0= ((frame[AudioChannel] & 0b11110000) >> 4) | ((frame[1+AudioChannel] & 0b00001111) << 4)
elif Sensibil ==2:
frame0= ((frame[AudioChannel] & 0b11100000) >> 5) | ((frame[1+AudioChannel] & 0b00011111) << 3)
elif Sensibil ==1:
frame0= ((frame[AudioChannel] & 0b11000000) >> 6) | ((frame[1+AudioChannel] & 0b00111111) << 2)
elif Sensibil ==5:
frame0=frame[AudioChannel]
if frame0 > ValorPico:
ValorPico= frame0
else: # AutoAudioSense Ligado
if SampW ==1:
if frame[AudioChannel]> obg.MaxAudio:
obg.MaxAudio = frame[AudioChannel]
if frame[AudioChannel]> ValorPico:
ValorPico=frame[AudioChannel]
if SampW ==2:
if frame[1+AudioChannel] < 127:
tmpValorPico= frame[1+AudioChannel] << 8
tmpValorPico+= frame[AudioChannel]
if tmpValorPico > obg.MaxAudio:
obg.MaxAudio = tmpValorPico
if tmpValorPico > ValorPico:
ValorPico= tmpValorPico
if bAutoSense==0: #autoaudiosense desligado
# repito o valor de frames por actions (OTIMIZAR)
for ii in range(DivSens):
array[j+obg.RunFrom]=ValorPico # valor de pico encontrado
j +=1 # incrementa indice prox local
else:
idx=obg.RunFrom*2 # porque sao dois bytes
arrayAutoSense[j+idx]= (ValorPico & 0b0000000011111111) #copia valores baixos
arrayAutoSense[j+1+idx]= (ValorPico & 0b1111111100000000) >> 8 #copia valores altos
j+=2
if bAutoSense==0: #autoaudiosense desligado
igraph= ValorPico//10
else:
if SampW ==2:
igraph= ValorPico//1261
else:
igraph= ValorPico//10
stgraph="["
for iii in range(igraph):
stgraph+="+"
for iiii in range(26-igraph):
stgraph+=" "
stgraph+="]"
print ("Sample-> " + str(ValorPico) + "\tAudio Frame # " + str(jj+obg.RunFrom) + " of " + str(looptot-1) + "\t"+ stgraph)
# acabou primeira fase roda toda de uma vez
if obg.RunFrom+loop == looptot:
if bAutoSense==1:
print("")
print("================================================================")
print('Calculating Auto Audio Sentivity, pass 2 of 2.')
print("================================================================")
# caso usar batida, procurar por valores proximos do maximo e zerar restante.
# caso retirar batida, zerar valores proximos do maximo
UseMinim=0
UseMax=0
if bUseBeat==1:
print("Trying to use just the beat.")
UseMinim= obg.MaxAudio*0.8
if bMoreSensible:
UseMinim= obg.MaxAudio*0.7
elif bLessSensible:
UseMinim= obg.MaxAudio*0.9
if bRemoveBeat==1:
print("Trying to exclude the beat.")
UseMax= obg.MaxAudio*0.7
if bMoreSensible:
UseMax= obg.MaxAudio*0.8
elif bLessSensible:
UseMax= obg.MaxAudio*0.7
print("")
# para transformar 15 bits em 8 calibrando valor maximo -> fazer regra de 3
# obg.MaxAudio -> 255
# outros valores => valor calibrado= (255 * Valor) / obg.MaxAudio
scale= 255/obg.MaxAudio
j=0
jj=0
print ("Sample->[value]\tAudio Frame # \t\t[Graph Value]")
for i in range(BytesDadosTotProcess // DivSens):
ValorOriginal= arrayAutoSense[j+1] << 8
ValorOriginal+= arrayAutoSense[j]
if bUseBeat==1:
if ValorOriginal < UseMinim:
ValorOriginal = 0
elif bRemoveBeat==1:
if ValorOriginal > UseMax:
ValorOriginal = 0
ValorOriginal= ((round(ValorOriginal * scale)) & 0b11111111) #aplica a escala
for ii in range(DivSens):
array[jj] = ValorOriginal
jj += 1 # se autoaudiosense, o array tem dois bytes para cada valor
j+=2
igraph= round(array[jj-1]/10)
stgraph="["
for iii in range(igraph):
stgraph+="+"
for iiii in range(26-igraph):
stgraph+=" "
stgraph+="]"
print ("Sample-> " + str(array[jj-1]) + "\tAudio Frame # " + str(i) + " of " + str(looptot-1) + "\t"+ stgraph)
#limpa array tmp
del arrayAutoSense[:]
# mensagens finais
context.scene.imp_sound_to_anim.Info_Import= "Click \"Import Key frames\" to begin import" #this set the initial text
print("================================================================")
from time import strftime
print(strftime("End Process: %H:%M:%S"))
print("================================================================")
try:
obg.Wave_read.close()
except:
print('File Close Error')
obg.RunFrom=0
return obg.RunFrom # acabou tudo
else:#ainda nao acabou o arquivo todo if RunFrom+loop = looptot:
context.scene.imp_sound_to_anim.Info_Import="Processing " + str(obg.RunFrom) + " of " + str(looptot) +" Audio Frames"
# force update info text in UI
bpy.context.scene.frame_current= bpy.context.scene.frame_current
obg.RunFrom+=loop
return obg.RunFrom
def ProcessaSom(context, loop):
obg= OBJECT_OT_Botao_Go
# para de entrar o timer
context.scene.imp_sound_to_anim.Working=""
#reseta contadores caso seja pedido
if context.scene.imp_sound_to_anim.timer_reset_func:
obg.RunFrom=0
context.scene.imp_sound_to_anim.timer_reset_func=False
import os
f= os.path.join(context.scene.imp_sound_to_anim.directory, context.scene.imp_sound_to_anim.filename)
f= os.path.normpath(f)
if obg.RunFrom==0:
print ("")
print ("")
print ("Selected file = ",f)
checktype = f.split('\\')[-1].split('.')[1]
if checktype.upper() != 'WAV':
print ("ERROR!! Selected file = ", f)
print ("ERROR!! Its not a .wav file")
return
#sensibilidade volume do audio 0 a 5. Quanto maior, mais sensibilidade
iAudioSensib= int(context.scene.imp_sound_to_anim.audio_sense)-1
if iAudioSensib <0: iAudioSensib=0
elif iAudioSensib>5: iAudioSensib=5
#act/s nao pode se maior que frames/s
if context.scene.imp_sound_to_anim.action_per_second > context.scene.imp_sound_to_anim.frames_per_second:
context.scene.imp_sound_to_anim.action_per_second = context.scene.imp_sound_to_anim.frames_per_second
#Frames por segundo para key frame
iFramesPorSeg= int(context.scene.imp_sound_to_anim.frames_per_second)
#Sensibilidade de movimento. 3= 3 movimentos por segundo
iMovPorSeg= int(context.scene.imp_sound_to_anim.action_per_second)
#iDivMovPorSeg Padrao - taxa 4/s ou a cada 0,25s => iFramesPorSeg/iDivMovPorSeg= ~0.25
for i in range(iFramesPorSeg):
iDivMovPorSeg=iFramesPorSeg/(i+1)
if iFramesPorSeg/iDivMovPorSeg >=iMovPorSeg:
break
bRemoveBeat= context.scene.imp_sound_to_anim.remove_beat
bUseBeat= context.scene.imp_sound_to_anim.use_just_beat
bLessSensible= context.scene.imp_sound_to_anim.beat_less_sensible
bMoreSensible= context.scene.imp_sound_to_anim.beat_more_sensible
AudioChannel= context.scene.imp_sound_to_anim.audio_channel_select
# chama funcao de converter som, retorna preenchendo _Interna_Globals.array
index= OBJECT_OT_Botao_Go.SoundConv(f, int(iDivMovPorSeg), iAudioSensib, iFramesPorSeg, context, \
context.scene.imp_sound_to_anim.action_auto_audio_sense, bRemoveBeat, \
bUseBeat, bMoreSensible, bLessSensible, AudioChannel, loop)
return index
def execute(self, context):
# copia dados dialof open wave
context.scene.imp_sound_to_anim.filter_glob= self.filter_glob
context.scene.imp_sound_to_anim.path = self.path
context.scene.imp_sound_to_anim.filename = self.filename
context.scene.imp_sound_to_anim.directory = self.directory
context.scene.imp_sound_to_anim.Working= "ProcessaSom"
bpy.ops.wm.modal_timer_operator()
#ProcessaSom(context)
return{'FINISHED'}
def invoke(self, context, event):
#need to set a path so so we can get the file name and path
wm = context.window_manager
wm.fileselect_add(self)
return {'RUNNING_MODAL'}
#
#==================================================================================================
# Button - Check Smart Render
#==================================================================================================
#
class OBJECT_OT_Botao_Check_SmartRender(bpy.types.Operator):
'''Check for Reduction'''
bl_idname = "import.sound_animation_botao_check_smartrender"
bl_label = "Check Smart Render"
RunFrom=0
Frames_Renderizar=0
Frames_Pular=0
def CheckSmartRender(context, loop):
obc= OBJECT_OT_Botao_Check_SmartRender
#reseta contadores caso seja pedido
if context.scene.imp_sound_to_anim.timer_reset_func:
obc.RunFrom=0
obc.Frames_Pular=0
obc.Frames_Renderizar=0
context.scene.imp_sound_to_anim.timer_reset_func=False
if obc.RunFrom==0:
if loop !=1: # loop==1 quando estou chamando de dentro da funcao render
print("")
print("================================================================")
print('Running Check Smart Render...')
#garante ao menos locrotscale ligado
if context.scene.imp_sound_to_anim.check_smartrender_loc_rot_sc==False and \
context.scene.imp_sound_to_anim.check_smartrender_material_basic==False and \
context.scene.imp_sound_to_anim.check_smartrender_material_transparence==False and \
context.scene.imp_sound_to_anim.check_smartrender_material_mirror==False:
context.scene.imp_sound_to_anim.check_smartrender_loc_rot_sc=True
chkLocRotSc= context.scene.imp_sound_to_anim.check_smartrender_loc_rot_sc
chkMatBas= context.scene.imp_sound_to_anim.check_smartrender_material_basic
chkMatTransp= context.scene.imp_sound_to_anim.check_smartrender_material_transparence
chkMatMirror= context.scene.imp_sound_to_anim.check_smartrender_material_mirror
ToRender=[]
origloop=loop
from copy import copy
RunMax= bpy.context.scene.frame_end - bpy.context.scene.frame_start+1
if obc.RunFrom+loop > RunMax:
loop= RunMax-obc.RunFrom
if loop<=0: #acabou
if origloop !=1: # loop==1 quando estou chamando de dentro da funcao render
print("")
print("Frames to copy: " + str(obc.Frames_Pular) + " Frames to really render= " + str(obc.Frames_Renderizar))
print("================================================================")
print("")
obc.RunFrom=0
obc.Frames_Pular=0
obc.Frames_Renderizar=0
return (ToRender, obc.RunFrom)
#move para o primeiro frame a renderizar
#RunFrom inicia em zero - frames inicia em 1
bpy.context.scene.frame_current = obc.RunFrom+bpy.context.scene.frame_start
for k in range(loop):
if obc.RunFrom==0 and k==0: #primeiro sempre renderiza
ToRender.append(bpy.context.scene.frame_current)
obc.Frames_Renderizar+=1
bpy.context.scene.frame_set(bpy.context.scene.frame_current + 1)
else:
if origloop !=1: # loop==1 quando estou chamando de dentro da funcao render
import sys
sys.stdout.write("\rChecking Frame "+str(bpy.context.scene.frame_current) + " ")
sys.stdout.flush()
#buffer de todos os objetos
a=[]
for obj in bpy.data.objects:
if chkLocRotSc:
# loc rot scale
a.append(copy(obj.location))
a.append(copy(obj.rotation_euler))
a.append(copy(obj.scale))
if hasattr(obj.data, 'materials') and obj.data.materials.keys()!=[] :
if bpy.context.scene.render.engine == "BLENDER_RENDER":
#pega somente primeiro material sempre
if chkMatBas:
# cores
a.append(copy(obj.data.materials[0].type))
a.append(copy(obj.data.materials[0].emit))
a.append(copy(obj.data.materials[0].diffuse_color))
a.append(copy(obj.data.materials[0].diffuse_intensity))
a.append(copy(obj.data.materials[0].specular_intensity))
a.append(copy(obj.data.materials[0].specular_color))
a.append(copy(obj.data.materials[0].alpha))
a.append(copy(obj.data.materials[0].diffuse_shader))
a.append(copy(obj.data.materials[0].specular_shader))
a.append(copy(obj.data.materials[0].specular_hardness))
if chkMatTransp:
# transp
a.append(copy(obj.data.materials[0].transparency_method))
a.append(copy(obj.data.materials[0].specular_alpha))
a.append(copy(obj.data.materials[0].raytrace_transparency.fresnel))
a.append(copy(obj.data.materials[0].raytrace_transparency.ior))
a.append(copy(obj.data.materials[0].raytrace_transparency.filter))
a.append(copy(obj.data.materials[0].raytrace_transparency.depth))
a.append(copy(obj.data.materials[0].translucency))
a.append(copy(obj.data.materials[0].specular_alpha))
if chkMatMirror:
#mirror
a.append(copy(obj.data.materials[0].raytrace_mirror.reflect_factor))
a.append(copy(obj.data.materials[0].raytrace_mirror.fresnel))
a.append(copy(obj.data.materials[0].raytrace_mirror.fresnel_factor))
a.append(copy(obj.data.materials[0].mirror_color))
a.append(copy(obj.data.materials[0].raytrace_mirror.depth))
a.append(copy(obj.data.materials[0].raytrace_mirror.gloss_factor))
# tenho todos os objetos em a[]
# incrementar um frame e checar se eh igual
bpy.context.scene.frame_set(bpy.context.scene.frame_current + 1)
j=0
dif=0
for obj in bpy.data.objects:
if chkLocRotSc:
if a[j]!= obj.location or a[j+1]!= obj.rotation_euler or a[j+2]!= obj.scale:
dif=1
#break
j+=3
if hasattr(obj.data, 'materials') and obj.data.materials.keys()!=[] :
if bpy.context.scene.render.engine == "BLENDER_RENDER":
if chkMatBas:
# cores
if a[j]!= obj.data.materials[0].type or a[j+1]!= obj.data.materials[0].emit or \
a[j+2]!= obj.data.materials[0].diffuse_color or \
a[j+3]!= obj.data.materials[0].diffuse_intensity or \
a[j+4]!= obj.data.materials[0].specular_intensity or \
a[j+5]!= obj.data.materials[0].specular_color or \
a[j+6]!= obj.data.materials[0].alpha or \
a[j+7]!= obj.data.materials[0].diffuse_shader or \
a[j+8]!= obj.data.materials[0].specular_shader or \
a[j+9]!= obj.data.materials[0].specular_hardness:
dif=1
print("mat")
j+= 10 # ajusta ponteiro j
if chkMatTransp: j+=8
if chkMatMirror: j+=6
break
j+=10
if chkMatTransp:
#transp
if a[j]!= obj.data.materials[0].transparency_method or a[j+1]!= obj.data.materials[0].specular_alpha or \
a[j+2]!= obj.data.materials[0].raytrace_transparency.fresnel or \
a[j+3]!= obj.data.materials[0].raytrace_transparency.ior or \
a[j+4]!= obj.data.materials[0].raytrace_transparency.filter or \
a[j+5]!= obj.data.materials[0].raytrace_transparency.depth or \
a[j+6]!= obj.data.materials[0].translucency or \
a[j+7]!= obj.data.materials[0].specular_alpha:
dif=1
j+= 8 # ajusta ponteiro j
if chkMatMirror: j+=6
break
j+=8
if chkMatMirror:
#mirror
if a[j]!= obj.data.materials[0].raytrace_mirror.reflect_factor or a[j+1]!= obj.data.materials[0].raytrace_mirror.fresnel or \
a[j+2]!= obj.data.materials[0].raytrace_mirror.fresnel_factor or \
a[j+3]!= obj.data.materials[0].mirror_color or \
a[j+4]!= obj.data.materials[0].raytrace_mirror.depth or \
a[j+5]!= obj.data.materials[0].raytrace_mirror.gloss_factor:
dif=1
j+= 6 # ajusta ponteiro j
break
j+=6
# finaliza
if dif==0:
obc.Frames_Pular+=1
else:
obc.Frames_Renderizar+=1
ToRender.append(bpy.context.scene.frame_current)
del a
# para nao sair do index - nunca chega nesse frame
ToRender.append(bpy.context.scene.frame_end+1)
if obc.RunFrom+loop < RunMax:
context.scene.imp_sound_to_anim.Info_check_smartrender= "["+str(obc.RunFrom+loop) + "/" + \
str(RunMax) + "] Frames to Render= " + str(obc.Frames_Renderizar) + \
" -> Reduction " + str(round((obc.Frames_Pular/RunMax)*100,1)) + "%"
else:
context.scene.imp_sound_to_anim.Info_check_smartrender= "Frames to Render= " + str(obc.Frames_Renderizar) + \
" -> Reduction " + str(round((obc.Frames_Pular/RunMax)*100,1)) + "%"
#incrementa indice
obc.RunFrom+= loop
return (ToRender, obc.RunFrom)
def execute(self, context):
context.scene.imp_sound_to_anim.Working= "CheckSmartRender"
#context.scene.imp_sound_to_anim.timer_reset_func=True
bpy.ops.wm.modal_timer_operator()
#CheckSmartRender(context)
return{'FINISHED'}
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
#
#==================================================================================================
# Button - Smart Render
#==================================================================================================
#
class OBJECT_OT_Botao_SmartRender(bpy.types.Operator):
'''Render Only Modified Frames and Copy the Others'''
bl_idname = "import.sound_animation_smart_render"
bl_label = "Smart Render"
BaseRenderToCopy=0
def SmartRender(context):
obs=OBJECT_OT_Botao_SmartRender
index=0
pad=4
#calcula zero pad
if bpy.context.scene.frame_end //1000000 > 0: #default 999999 1000000//1000000=1
pad=7
elif bpy.context.scene.frame_end //100000 > 0: #default 99999 100000//100000=1
pad=6
elif bpy.context.scene.frame_end //10000 > 0: #default 9999 10000//10000=1
pad=5
#bpy.data.images['Render Result'].file_format ='PNG'
bpy.context.scene.render.image_settings.file_format = 'PNG'
#info dos arquivos
path= bpy.context.scene.render.filepath
import shutil
tot=bpy.context.scene.frame_end - bpy.context.scene.frame_start+1
i=0
# checa apenas 1 frame o indice é interno em ChackSmartRender
r= OBJECT_OT_Botao_Check_SmartRender.CheckSmartRender(context, 1)
ToRender= r[0] # tem numero do frame se for para renderizar
index= r[1]
#copia frame atual #se o frame ja não foi renderizado
if (obs.BaseRenderToCopy!=(index+bpy.context.scene.frame_start-1)) and index > 1: #index!=1 and index !=0:
print("Copying: " + str(obs.BaseRenderToCopy) + "-> " + str(index+bpy.context.scene.frame_start-1) + \
" To " + path + str(index+bpy.context.scene.frame_start-1).zfill(pad) + ".png")
shutil.copy2(path + str(obs.BaseRenderToCopy).zfill(pad) + ".png", path + \
str(index+bpy.context.scene.frame_start-1).zfill(pad) + ".png")
if ToRender.__len__()>1: #renderizar 1 item em ToRender nao renderiza, (sempre vem com no minimo 1)
if index==1:
print("================================================================")
from time import strftime
print(strftime("Running Smart Render: %H:%M:%S"))
print("================================================================")
BaseRenderToCopy=0
if ToRender[0] <= bpy.context.scene.frame_end:
#renderiza proximo frame
print("Rendering-> " + str(ToRender[0]))
obs.BaseRenderToCopy= ToRender[0]
bpy.ops.render.render(animation=False, write_still=False)
bpy.data.images['Render Result'].save_render(filepath=path + str(ToRender[0]).zfill(pad) + ".png")
i+=1
if index==tot:
print("================================================================")
from time import strftime
print(strftime("Finish Render: %H:%M:%S"))
print("================================================================")
print(".")
if index==tot+1:
obs.BaseRenderToCopy=0
return 0
return index
def execute(self, context):
# se for CYCLES, nao funciona com timer, preciso rodar direto
context.scene.imp_sound_to_anim.Working= "SmartRender"
bpy.ops.wm.modal_timer_operator()
#SmartRender(context)
return{'FINISHED'}
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
#
#==================================================================================================
# Button - Cancel
#==================================================================================================
#
class OBJECT_OT_Botao_Cancel(bpy.types.Operator):
'''Cancel Actual Operation'''
bl_idname = "import.sound_animation_botao_cancel"
bl_label = "CANCEL"
def execute(self, context):
context.scene.imp_sound_to_anim.cancel_button_hit=True
return{'FINISHED'}
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
#
#==================================================================================================
# TIMER - controla a execucao das funcoes
# Responsavel por rodar em partes usando o timer e possibilitando
# o cancelamento e textos informativos
#==================================================================================================
#
class ModalTimerOperator(bpy.types.Operator):
"""Internal Script Control"""
bl_idname = "wm.modal_timer_operator"
bl_label = "Internal Script Control"
_timer = None
Running= False
def CheckRunStop(self, context, func, index):
# forca update do UI
bpy.context.scene.frame_set(bpy.context.scene.frame_current)
if index!=0:
#configura timer para a funcao
context.scene.imp_sound_to_anim.Working= func
self.Running=True
return {'PASS_THROUGH'}
else: # posso desligar o timer e modal
if self._timer!= None:
context.window_manager.event_timer_remove(self._timer)
self._timer= None
return {'FINISHED'}
def modal(self, context, event):
if event.type == 'ESC'and self.Running:
print("-- ESC Pressed --")
self.cancel(context)
context.scene.imp_sound_to_anim.Working=""
self.Running=False
#reseta contadores
context.scene.imp_sound_to_anim.timer_reset_func=True
# forca update do UI
bpy.context.scene.frame_set(bpy.context.scene.frame_current)
return {'CANCELLED'}
if event.type == 'TIMER':
#print("timer")
#CheckSmartRender
if context.scene.imp_sound_to_anim.Working== "CheckSmartRender":
self.parar(context)
#5= frames para rodar antes de voltar [1]= indice de posicao atual
index= OBJECT_OT_Botao_Check_SmartRender.CheckSmartRender(context, 5)[1]
return self.CheckRunStop(context, "CheckSmartRender", index)
#SmartRender
elif context.scene.imp_sound_to_anim.Working== "SmartRender":
self.parar(context)
#render/copia 1 e volta index>=0 indice posicao atual
index= OBJECT_OT_Botao_SmartRender.SmartRender(context)
return self.CheckRunStop(context, "SmartRender", index)
#ProcessaSom
elif context.scene.imp_sound_to_anim.Working== "ProcessaSom":
self.parar(context)
# loop = numero de frames de audio index=0 se terminou ou >0 se não acabou
index= OBJECT_OT_Botao_Go.ProcessaSom(context, 50)
return self.CheckRunStop(context, "ProcessaSom", index)
#wavimport(context)
elif context.scene.imp_sound_to_anim.Working== "wavimport":
self.parar(context)
# 5= numero de frames to import por timer
index=OBJECT_OT_Botao_Import.wavimport(context, 50)
return self.CheckRunStop(context, "wavimport", index)
#passa por aqui quando as funcoes estao sendo executadas mas
#configuradas para nao entrar porque context.scene.imp_sound_to_anim.Working== ""
return {'PASS_THROUGH'}
# reseta e para tudo botao CANCEL pressionado
if context.scene.imp_sound_to_anim.cancel_button_hit==True:
context.scene.imp_sound_to_anim.Working=""
#pede reset contadores
context.scene.imp_sound_to_anim.timer_reset_func=True
if self._timer!= None:
context.window_manager.event_timer_remove(self._timer)
self._timer= None
print("-- Cancel Pressed --")
context.scene.imp_sound_to_anim.cancel_button_hit=False
return {'FINISHED'}
#print("modal")
# se o timer esta ativado, continua, (senao termina).
# desligar a chamada ao modal se caso chegar aqui (nao deveria)
if self._timer!= None:
return{'PASS_THROUGH'}
else:
return {'FINISHED'}
def execute(self, context):
if self._timer==None:
self._timer = context.window_manager.event_timer_add(0.2, context.window)
context.window_manager.modal_handler_add(self)
#para deixar rodar sem deligar o timer
context.scene.imp_sound_to_anim.timer_desligar=False
self.Running=True
return {'RUNNING_MODAL'}
def cancel(self, context):
if self._timer!= None:
context.window_manager.event_timer_remove(self._timer)
self._timer= None
def parar(self, context):
if self.Running:
context.scene.imp_sound_to_anim.Working=""
self.Running=False
#
#==================================================================================================
# Register - Unregister - MAIN
#==================================================================================================
#
def register():
bpy.utils.register_module(__name__)
bpy.types.Scene.imp_sound_to_anim = PointerProperty(type=ImpSoundtoAnim, name="Import: Sound to Animation", description="Extract movement from sound file. See the Object Panel at the end.")
bpy.types.TOPBAR_MT_file_import.append(WavFileImport)
def unregister():
try:
bpy.utils.unregister_module(__name__)
except:
pass
try:
bpy.types.TOPBAR_MT_file_import.remove(WavFileImport)
except:
pass
if __name__ == "__main__":
register()