255 lines
8.5 KiB
Ruby
Executable File
255 lines
8.5 KiB
Ruby
Executable File
#
|
|
# File:: %RS_TOOLSLIB%/pipeline/resourcing/converters/converter_animation_coalesce.rb
|
|
# Description:: Animation Coalescing processor.
|
|
#
|
|
# Author:: Luke Openshaw
|
|
# Date:: 22nd November 2011
|
|
#
|
|
|
|
#----------------------------------------------------------------------------
|
|
# Uses
|
|
#----------------------------------------------------------------------------
|
|
#require 'pipeline/config/projects'
|
|
require 'pipeline/content/content_core'
|
|
require 'pipeline/os/file'
|
|
require 'pipeline/os/path'
|
|
require 'pipeline/os/start'
|
|
require 'pipeline/projectutil/data_zip'
|
|
require 'pipeline/resourcing/converter'
|
|
require 'pipeline/fileformats/clipascii'
|
|
include Pipeline
|
|
include Pipeline::Resourcing
|
|
|
|
#----------------------------------------------------------------------------
|
|
# Implementation
|
|
#----------------------------------------------------------------------------
|
|
module Pipeline
|
|
module Resourcing
|
|
module Converters
|
|
|
|
#
|
|
# == Description
|
|
# Animation Coalescing processor.
|
|
#
|
|
class AnimationConverterCoalesce < ChildConverterBase
|
|
attr_reader :items
|
|
attr_reader :use_xge
|
|
attr_reader :conf
|
|
|
|
def initialize( project, branch )
|
|
super( project, branch )
|
|
|
|
@items = []
|
|
@use_xge = ( Pipeline::Config::instance().use_xge and Incredibuild.is_installed?() )
|
|
@conf = Pipeline::Config::instance()
|
|
end
|
|
|
|
# Build the content.
|
|
def build( content_node_list, input_lists, &block )
|
|
result = true
|
|
|
|
prebuild_internal( content_node_list, input_lists )
|
|
begin
|
|
if @use_xge then
|
|
result = build_xge( &block )
|
|
else
|
|
result = build_local( &block )
|
|
end
|
|
rescue BuildError => ex
|
|
result = false
|
|
throw
|
|
end
|
|
@items = []
|
|
result
|
|
end
|
|
|
|
def AnimationConverterCoalesce::processor(dir, file_list )
|
|
puts "Coalesce process has started for #{dir}"
|
|
coalesce_exe = CLIP_COALESCE_EXE
|
|
combine_exe = ANIM_COMBINE_EXE
|
|
edit_exe = ANIM_EDIT_EXE
|
|
dof_xml = DOF_INJECTION_XML
|
|
|
|
Pipeline::Globals.instance().in_env do |e|
|
|
coalesce_exe = e.subst(coalesce_exe)
|
|
combine_exe = e.subst(combine_exe)
|
|
edit_exe = e.subst(edit_exe)
|
|
dof_xml = e.subst(dof_xml)
|
|
end
|
|
|
|
xmldoc = REXML::Document.new( File.new(dof_xml) )
|
|
if not xmldoc then
|
|
puts "ERROR: Failed to load file: #{dof_xml}"
|
|
exit( -1 )
|
|
end
|
|
|
|
skeletons = []
|
|
xmldoc.elements.each( '/Skeletons/Item' ) do |item|
|
|
skeletons << item.text
|
|
end
|
|
|
|
file_list.each do | zip |
|
|
clip_list_files = OS::FindEx.find_files(dir + "/*.cliplist")
|
|
|
|
# First lets apply additive / dof injection
|
|
clip_list_files.each do | clip_list |
|
|
clip_list_base = OS::Path.get_basename( clip_list )
|
|
clip_list_tokens = clip_list_base.split( '@' )
|
|
additive = clip_list_tokens[2].to_i
|
|
File.open(clip_list) do |clip_list_file|
|
|
begin
|
|
clip_list_file.each do |clip_file|
|
|
anim_file = OS::Path.remove_extension( clip_file ) + ".anim"
|
|
if not File.exist?( anim_file )
|
|
puts "ERROR: Failed to make additive/inject dof: #{anim_file} does not exist"
|
|
exit( -1 )
|
|
end
|
|
|
|
if additive == 1 then
|
|
puts "Processing as additive #{anim_file}"
|
|
additive_command = combine_exe + " -anims #{anim_file},#{anim_file} -subtract -time 0 -out #{anim_file} -nocompress -nopopups -output"
|
|
status, out, err = OS::start( additive_command )
|
|
if ( status.exitstatus != 0 ) then
|
|
puts "ERROR: Failed to make additive: #{anim_file}"
|
|
exit( status.exitstatus )
|
|
end
|
|
end
|
|
|
|
skel_file = clip_list_tokens[1] + ".skel"
|
|
|
|
skeletons.each_index do |skeleton_index|
|
|
if skel_file.index(skeletons[skeleton_index]) != nil then
|
|
edit_command = edit_exe + " -anim=#{anim_file} -out=#{anim_file} -op add[134,0]=float(0.0)"
|
|
status, out, err = OS::start( edit_command )
|
|
if ( status.exitstatus != 0 ) then
|
|
puts "ERROR: Failed to inject DOF into #{anim_file}"
|
|
exit( status.exitstatus )
|
|
end
|
|
puts "WARNING: Injected DOF: #{anim_file} - skel: #{skel_file}"
|
|
end
|
|
end
|
|
|
|
end
|
|
ensure
|
|
clip_list_file.close()
|
|
end
|
|
end
|
|
end
|
|
|
|
clip_list_files.each do | clip_list |
|
|
clip_list_name = OS::Path.get_basename(clip_list)
|
|
output_dir = OS::Path.combine( dir, clip_list_name )
|
|
FileUtils::mkdir( output_dir ) unless ( File::directory?( output_dir ) )
|
|
|
|
coalesce_command = coalesce_exe + " -cliplist=#{clip_list} -outdir=#{output_dir} -outprefix=#{OS::Path.get_basename(clip_list)}_ -framelimit=200 -score -nopopups -output"
|
|
puts "Coalesce command: #{coalesce_command}"
|
|
status, out, err = OS::start( coalesce_command )
|
|
puts out
|
|
if ( status.exitstatus != 0 ) then
|
|
puts "Failed to process #{clip_list}"
|
|
exit( status.exitstatus )
|
|
end
|
|
end
|
|
end
|
|
end
|
|
#--------------------------------------------------------------------
|
|
# Private
|
|
#--------------------------------------------------------------------
|
|
private
|
|
CLIP_COALESCE_EXE = '$(toolsbin)/anim/clipcoalesce.exe'
|
|
ANIM_COMBINE_EXE = '$(toolsbin)/anim/animcombine.exe'
|
|
ANIM_EDIT_EXE = '$(toolsbin)/anim/animedit.exe'
|
|
DOF_INJECTION_XML = '$(toolsroot)/etc/config/anim/dof_injection_skeletons.xml'
|
|
|
|
def build_local( )
|
|
status = 0
|
|
@command_list.each_key do | key |
|
|
status, out, err = OS::start( @command_list[key] )
|
|
if ( status.exitstatus == 0 ) then
|
|
AnimationConverter::log().info( "Coalesce of clips for #{key} succeded." )
|
|
else
|
|
AnimationConverter::log().error( "Coalesce of clips for #{key} failed." )
|
|
end
|
|
end
|
|
status.exitstatus == 0
|
|
end
|
|
|
|
def build_xge()
|
|
result = true
|
|
if ( 0 == @items.size ) then
|
|
|
|
AnimationConverter::log().info( "Nothing to convert." )
|
|
else
|
|
AnimationConverter::log().info( "Creating XGE animation processing packets." )
|
|
xge_folder = XGE::get_temp_dir( @project, @branch.name )
|
|
xge_packet_folder = OS::Path::combine( xge_folder, 'anim_coalesce' )
|
|
filename = OS::Path.combine( xge_packet_folder, 'anim_coalesce.xml' )
|
|
@log_filename = OS::Path.combine( xge_packet_folder, 'anim_coalesce.log' )
|
|
|
|
xge_packets = GenericPacketList.new( xge_packet_folder, "AnimationConverterCoalesce", :processor, false, 1024 )
|
|
@items.each do |item|
|
|
xge_packets.add_item( item )
|
|
end
|
|
xge_packets.create( )
|
|
|
|
AnimationConverter::log().info( "Creating XGE task" )
|
|
# Create environment and tools
|
|
options = ""
|
|
tool = XGE::Tool.ruby( "anim_colaesce", "")
|
|
|
|
xge_env = XGE::Environment.new( "env_anim_coalesce" )
|
|
xge_env.add_tool( tool )
|
|
|
|
# Construct XGE Project
|
|
xge_project = XGE::Project.new( "#{@project.uiname} Animation Coalescing" )
|
|
xge_taskgroup = XGE::TaskGroup.new( "Animation Coalescing", [], xge_env, xge_env.tools[0] )
|
|
|
|
# Construct XGE TaskGroup
|
|
xge_packets.packets.each do | packet |
|
|
task_name = "anim_coalesce"
|
|
task = XGE::Task.new( task_name, packet.filename )
|
|
task.caption = "#{task_name}"
|
|
task.parameters = packet.filename
|
|
|
|
xge_taskgroup.tasks << task
|
|
end
|
|
|
|
xge_project.add_task( xge_taskgroup )
|
|
xge_project.write( filename )
|
|
|
|
AnimationConverter::log().info( "Starting XGE coalescing process." )
|
|
if ( not XGE::start( filename, @log_filename ) ) then
|
|
AnimationConverter::log().error( "Animation Coalesce failed. Check Build Monitor for errors." )
|
|
|
|
result = false
|
|
if ( not @conf.user.username.downcase.include?( User::ASSETBUILDER_USER) )
|
|
error_msg = "XGE Animation Coalescing failed. Check #{@log_filename} for errors."
|
|
GUI::MessageBox::error("XGE Error Notification", error_msg)
|
|
end
|
|
end
|
|
end
|
|
result
|
|
end
|
|
|
|
def prebuild_internal( content_node_list, input_lists )
|
|
result = true
|
|
content_node_list.each do | content_node |
|
|
cache_dir = AnimationConverter::cache_dir( @branch, content_node )
|
|
input_lists[content_node].each do | clip_node |
|
|
clip_basename = OS::Path.get_basename(clip_node.filename)
|
|
item = GenericItem.new( OS::Path.combine( cache_dir, OS::Path::remove_extension( clip_basename) ) )
|
|
item.set_files( [clip_node.filename] )
|
|
@items << item
|
|
end
|
|
end
|
|
result
|
|
end
|
|
|
|
def postbuild_internal()
|
|
|
|
end
|
|
end
|
|
|
|
end # Converters module
|
|
end # Resourcing module
|
|
end # Pipeline module |