v6.73+dev0112 - January 12 2023

[glymur]

Originally Posted by ferropop

A big hope is : now that there's those slices in the comp lane, you've adjusted things, there's crossfades - that if you want to audition other versions of a slice that you don't have to Re Swipe, or fiddle with Soloing Lanes, etc.

OG Comping you hit the Cycle next/previous Take keys and everything stays put. Crossfades, edges, great.

Is there a plan for non-destructive Razor-based auditioning like there was in that Early January pre? Nobody's talking about it, I found it to be the smartest most unique little feature, perfect for "after the comp is mostly done but you want to try something" scenarios.

Wouldn't this workflow be to "Comp into new copy of this lane"? Test things out, then if they don't work just remove it?

[mykrobinson]

Originally Posted by IrishRover79

Hi Myk,

Here's one way to do it:

1. Get items on fixed lanes - there's a new setting to record to fixed lanes or you can drag/copy and paste stuff manually
2. Right-click on any of the yellow lane button.
3. Choose comp to new empty lane. This will create an empty lane at the top. The yellow button will have a yellow square round it to show you're now in comping mode.
4. left-drag over the materials in the lanes to create a comp in the empty lane at the top. This is essentially creating copies of the material below in the top lane. It automatically solos whatever you've selected in this way, so only the comp lane is playing. You can redraw your selections and adjust boundaries as you need to.
5. To audition different takes within comp boundaries, you can use the new comping mouse modifiers. For me, CMD+left click will select the material within the same boundaries on the next lane and SHIFT+left click will select the stuff on the previous lane. This is a bit like the traditional next take and previous take actions. There is an action to to set your loop points so they're aligned with the comp boundaries.
6. Once you're happy, you can either turn off comping mode and edit right on the comping lane OR if you want to preverse that comp and keep it re-editable in future, you can copy the stuff on the comp lane to a new lane and edit that, e.g. fill gaps, add fades, use Melodyne etc.
7. As of the current version, lanes are nameable (there's an action for renaming them), reorderable, and work nicely with the new grouped track editing features (handy for drum editing! : -)) but we can't show only one lane at a time. Hopefully, that will come.... for now, don't turn off fixed lanes if you're using fixed unless you want everything to play. You've got to keep fixed lane mode on if you're using fixed lanes and select what you want to play.


Does this help? in case you're a visual learner:



Edit: obviously, I wouldn't put a crossfade right on top of a drum hit in real life! :-)

Thank you for taking the time to post that, I'm excited to test this when I get home. This will make.it much easier for me to follow along as this develops.

[ferropop]

Originally Posted by glymur

Wouldn't this workflow be to "Comp into new copy of this lane"? Test things out, then if they don't work just remove it?

I'm always gonna come at this being protective of Melodyne ARA, cause it's just SUCH a big part of vocals these days. To the point of not even bothering to using the new comping stuff if it doesn't play nice with ARA.

Undos + Melodyne are the equivalent of "I just built a house and maybe if I sneeze the big bang will reverse itself".

Apologies for the melodrama, but this is what it feels like when you've tuned 9 vocals and it all disappears.

So this said, non-committal auditioning using Razors (not clunkily soloing lanes!) would allow everything to play nice, and for space-time to remain intact. The idea of committing / undoing / committing / ... I feel anxiety just thinking about this.

[FeedTheCat]

Originally Posted by Kenny Gioia

Here's another thing I was thinking of. Imagine that you could trigger a linking mode that when turned ON, would highlight any item in a lane, when you select an item from the comp lane, that is basically the same file (showing up in the non-comp lanes). Regardless of where it is or it's timing or it's length. It would just highlight the item in the lane that is using the same source file. Then you could turn it off when you don't care. In this way, you would always see where the source file came from for that piece but still have the ability to treat it in the comp lane like every other media item on a track. The only way they would be disconnected would be if you were to glue your items and therefore it's a whole new item.

You can see it at the end here:

https://imgur.com/QhmGQn6

I had some spare time this evening... so I made you a little something



Definitely think you're on to something here. Really cool if you want to know where your comps came from, you can even tell if you ended up copying a part of the first refrain to the second etc. It should also work just fine with any form of editing (I didn't implement stretching, I don't hate myself enough)

Maybe the ghosted areas could also become interactive, e.g. you click on them to create razor edits. Kind of makes me wish that razor comping makes a compback

In case anyone wants to try it, here's the script:

local is_windows = reaper.GetOS():match('Win')
local main_hwnd = reaper.GetMainHwnd()
local arrange_hwnd = reaper.JS_Window_FindChildByID(main_hwnd, 1000)

local GetTakeInfo = reaper.GetMediaItemTakeInfo_Value
local GetItemInfo = reaper.GetMediaItemInfo_Value

local prev_sel_item
local prev_sel_item_cnt
local prev_vpos
local prev_hsize
local prev_hpos
local prev_vsize
local prev_edit_time
local prev_hzoom
local prev_item_h

local areas

function GetAreaCoords(item, start_offs, length)
    local track = reaper.GetMediaItem_Track(item)
    local track_y = reaper.GetMediaTrackInfo_Value(track, 'I_TCPY')

    local item_y = GetItemInfo(item, 'I_LASTY')
    local item_h = GetItemInfo(item, 'I_LASTH')

    local area_y = track_y + item_y
    local area_h = item_h

    local GetArrangeView = reaper.GetSet_ArrangeView2
    local av_start_pos, av_end_pos = GetArrangeView(0, false, 0, 0, 0, 0)
    local av_length = av_end_pos - av_start_pos

    local item_length = GetItemInfo(item, 'D_LENGTH')
    local item_start_pos = GetItemInfo(item, 'D_POSITION')
    local item_end_pos = item_start_pos + item_length

    local length = length or item_length
    local start_pos = item_start_pos

    if start_offs then
        local take = reaper.GetActiveTake(item)
        local take_start_offs = GetTakeInfo(take, 'D_STARTOFFS')
        start_pos = start_pos + start_offs - take_start_offs
    end

    local end_pos = start_pos + length

    if start_pos < item_start_pos then
        start_pos = item_start_pos
        end_pos = end_pos - (item_start_pos - start_pos)
    end

    end_pos = math.min(end_pos, item_end_pos)

    local _, av_pixel_w = reaper.JS_Window_GetClientSize(arrange_hwnd)
    -- Needed for scrollbar?
    av_pixel_w = av_pixel_w + 18

    local area_x = (start_pos - av_start_pos) / av_length * av_pixel_w
    local area_w = (end_pos - av_start_pos) / av_length * av_pixel_w - area_x

    return math.floor(area_x), area_y, math.floor(area_w), area_h
end

function AddAreas(main_item)
    local ghosted_items = {}

    local main_take = reaper.GetActiveTake(main_item)
    local main_source = reaper.GetMediaItemTake_Source(main_take)
    local main_file = reaper.GetMediaSourceFileName(main_source)

    local GetMIDIPool = reaper.BR_GetMidiTakePoolGUID
    local main_midi_pool = ''

    if reaper.TakeIsMIDI(main_take) and GetMIDIPool then
        main_midi_pool = select(2, GetMIDIPool(main_take))
    end

    local track = reaper.GetMediaItem_Track(main_item)

    for i = 0, reaper.CountTrackMediaItems(track) - 1 do
        local item = reaper.GetTrackMediaItem(track, i)
        local take = reaper.GetActiveTake(item)
        local source = reaper.GetMediaItemTake_Source(take)
        if reaper.TakeIsMIDI(take) then
            if main_midi_pool ~= '' then
                local _, midi_pool = GetMIDIPool(take)
                if midi_pool == main_midi_pool then
                    table.insert(ghosted_items, item)
                end
            end
        else
            local file = reaper.GetMediaSourceFileName(source)
            if file == main_file and item ~= main_item then
                table.insert(ghosted_items, item)
            end
        end
    end

    local alpha = is_windows and 0.5 or 1

    local main_area = {}
    local x, y, w, h = GetAreaCoords(main_item)
    main_area.pos = {x, y, w, h}
    main_area.bitmap = reaper.JS_LICE_CreateBitmap(true, w, h)
    reaper.JS_LICE_FillRect(main_area.bitmap, 0, 0, w, h, 0x6Fccdd66, alpha, 0)
    table.insert(areas, main_area)

    local main_length = GetItemInfo(main_item, 'D_LENGTH')
    local main_start_offs = GetTakeInfo(main_take, 'D_STARTOFFS')

    for _, item in ipairs(ghosted_items) do
        local area = {}
        local x, y, w, h = GetAreaCoords(item, main_start_offs, main_length)
        area.pos = {x, y, w, h}
        area.bitmap = reaper.JS_LICE_CreateBitmap(true, w, h)
        reaper.JS_LICE_FillRect(area.bitmap, 0, 0, w, h, 0x6F44ccdd, alpha, 0)
        table.insert(areas, area)
    end
end

function DestroyBitmaps(areas)
    if not areas then return end
    for _, area in ipairs(areas) do reaper.JS_LICE_DestroyBitmap(area.bitmap) end
end

function Main()

    local sel_item = reaper.GetSelectedMediaItem(0, 0)
    local sel_item_cnt = reaper.CountSelectedMediaItems(0)
    local _, vpos, vsize = reaper.JS_Window_GetScrollInfo(arrange_hwnd, 'v')
    local _, hpos, hsize = reaper.JS_Window_GetScrollInfo(arrange_hwnd, 'h')
    local edit_time = reaper.GetItemEditingTime2()
    local hzoom = reaper.GetHZoomLevel()
    local item_h = sel_item and GetItemInfo(sel_item, 'I_LASTH')

    if sel_item ~= prev_sel_item or sel_item_cnt ~= prev_sel_item_cnt or vpos ~=
        prev_vpos or vsize ~= prev_vsize or hpos ~= prev_hpos or hsize ~=
        prev_hsize or edit_time ~= prev_edit_time or hzoom ~= prev_hzoom or
        item_h ~= prev_item_h then

        prev_sel_item = sel_item
        prev_sel_item_cnt = sel_item_cnt
        prev_vpos = vpos
        prev_hsize = hsize
        prev_hpos = hpos
        prev_vsize = vsize
        prev_edit_time = edit_time
        prev_hzoom = hzoom
        prev_item_h = item_h

        DestroyBitmaps(areas)

        areas = {}
        for i = 0, sel_item_cnt - 1 do
            local item = reaper.GetSelectedMediaItem(0, i)
            AddAreas(item)
        end

        reaper.UpdateArrange()
    end

    if sel_item and areas then
        for _, area in ipairs(areas) do
            local bitmap = area.bitmap
            local x, y, w, h = table.unpack(area.pos)
            reaper.JS_Composite(arrange_hwnd, x, y, w, h, bitmap, 0, 0, w, h)
        end
    end
    reaper.defer(Main)
end

function Exit() DestroyBitmaps(areas) end
reaper.atexit(Exit)

Main()

[Vagelis]

Originally Posted by FeedTheCat

I had some spare time this evening... so I made you a little something

Wow very nice, I will definitely try it tomorrow. This is also a perfect example of how useful it would be if we could group a comp area in lanes with the enclosed item and move them together like with RE.

[FeedTheCat]

Some cool stuff I've noticed while playing around with it:

You can go through your sources to check out where they're being used. If a source has hasn't been used anywhere, it's probably a good indicator that you can just remove it.



You can quickly compare two (or more) comps, which might be a good tool to detect problematic areas.

[Coachz]

Originally Posted by schwa

I'm sorry that this is a line in the sand, but we're not going to add comping to the media item left-drag mouse modifiers. There are already 70 (!) defined mouse modifiers in that context, and it's not practical to use one up for a specialized purpose like this. More importantly, users will also want to initiate creating comp areas over empty track space, which is a different mouse modifier context, and item edges and fades, which are two different mouse modifier contexts. And if the mouse happens to target a take envelope instead of the item itself, the envelope mouse modifiers will apply instead.

It's the same problem that exists with marquee selection and creating razor edits. Those actions, plus creating comp areas, are behaviors you want to initiate over *any* object that happens to be on the screen. Marquee selection on left-drag is supported, sort of, but with all of the friction points described above. That's why those three actions are in the arrange right-drag context by default. That's why other software has "tools" that you select that enter a mode where only a certain set of behaviors are possible.

So these are the choices that I see: a dedicated mouse modifier context that applies only when comping is active (in other words, a comping tool :/), which is what's in the +dev0112 build, or initiating creating comp areas via right-drag, which is what's in the earlier builds.

I think a comping tool makes the most sense. This way you click a button or a fire in action with a single key on the keyboard and you're in comping mode where everything could be done with a left click like in other DAWs. It's like using a painting tool and switching between a brush tool and an eraser. They do it that way because it is a lot more intuitive and practical for people who have hundreds of thousands of hours of skill developed with left mouse actions. To do a comp with many lanes could require dozens of moves and makes more sense to do it with a left drag where you already have a strong skill developed.

Right drag just sucks in my world. I hated the right drag Marquee for many many years until it became available to left drag and I can't believe this comping tool for all of its potential is going back down that road unlike the other DAWs which give you a tool. Sadly after I've been begging for better comping for many many years I will likely not use this tool at all because it's right drag only. Not because I'm stubborn but simple because with my old way it will simply be faster and more accurate. Very disappointed.

[sockmonkey72]

Originally Posted by Coachz

I think a comping tool makes the most sense. This way you click a button or a fire in action with a single key on the keyboard and you're in comping mode where everything could be done with a left click like in other DAWs. It's like using a painting tool and switching between a brush tool and an eraser. They do it that way because it is a lot more intuitive and practical for people who have hundreds of thousands of hours of skill developed with left mouse actions. To do a comp with many lanes could require dozens of moves and makes more sense to do it with a left drag where you already have a strong skill developed.

Right drag just sucks in my world. I hated the right drag Marquee for many many years until it became available to left drag and I can't believe this comping tool for all of its potential is going back down that road unlike the other DAWs which give you a tool. Sadly after I've been begging for better comping for many many years I will likely not use this tool at all because it's right drag only. Not because I'm stubborn but simple because with my old way it will simply be faster and more accurate. Very disappointed.

Given the correct components, we can build our own "tool modes" using Mouse Modifier presets (which I've tried to address in my Mouse Maps Factory script).

I hope that the line in the sand, being in sand, can be blown away or smoothed over, and that the devs can see their way toward adding left-drag options for "Create fixed lane comp area" in all of the MM contexts where it makes sense. Like with Razor Edits and marquee selection. They can be off by default, but then we have options for situations where right-drag is a hardship.

I probably agree that there are too many MM options, and I recognize that adding left-drag stuff means adding it to 5 different contexts. Those are problems, but they are problems which the devs could actively improve (MM presets, improved MM ReaScript performance, consolidating MM contexts or defining a functional MM hierarchy to avoid needing to set stuff up in 5 different places, or whatever), rather than restricting access to functionality, or saying "my way or the highway" and forcing us to exclusively rely on user-hostile mouse gestures.

I say this with the utmost respect for the devs and the issues involved, but I also have respect for my body and its limits, and right-drag is, in that respect, a monstrosity.

[Vagelis]

Originally Posted by sockmonkey72

I probably agree that there are too many MM options, and I recognize that adding left-drag stuff means adding it to 5 different contexts. Those are problems, but they are problems which the devs could actively improve (MM presets, improved MM ReaScript performance, consolidating MM contexts or defining a functional MM hierarchy to avoid needing to set stuff up in 5 different places, or whatever), rather than restricting access to functionality, or saying "my way or the highway" and forcing us to exclusively rely on user-hostile mouse gestures.

I say this with the utmost respect for the devs and the issues involved, but I also have respect for my body and its limits, and right-drag is, in that respect, a monstrosity.

We 've reached that level and in the future more left drag mods may or have to be added who knows, but in any case I think this should not be a reason to hold back any feature developments.
This is why a native solution similar to your script should be concerned by the devs imo and let the user create his own Reatools
The user could work as usual in a tool-less environment, mouse presets will be there just to switch fast the behaviors for some cases where there are many modifiers without changing the usual workflow.

[Coachz]

Originally Posted by Funkybot

It seems like 1) you enter the "comp tool" workflow for creating the comp bounds, then 2) you drop out of the "comp tool" workflow and back to default for doing edits on the comps (slip editing, splits, volume adjustments, etc.). While performing edits, the comp "bounds" for each lane and the active take should remain in place. You're not editing the comps any longer. If you need to go back and tweak those, or the active take, you'd jump back into the comp tool workflow. As long as flip-flopping between comp and non-comp modes can be assigned to a keyboard shortcut/menu-icon, that shouldn't be onerous.

Is that now how this pre works?

That makes the most sense to me especially if the mode is allowing the left mouse to do it all

[Coachz]

Originally Posted by benmiller

The right clic and drag seems to get a lot of dislike but i find it a very smart way to add easily accessible functionnality. I use mostly an apple track pad and don't find it difficult to do. While testing i regularly do left drag by mistake, but i'm sure a couple hours of work with that feature would be enough to make it a habit. ( which you would en up missing in every other software )

That's great that it works for you. I tried the right drag Marquee select for a couple years and never got used to it. My friend also said trackballs were the greatest thing so I try to trackball for an entire year and never liked it either. I also tried listening to Miles Davis and John Coltrane for an entire year because somebody told me their jazz was awesome. I never liked it either and still don't. At least I do try things for a serious amount of time to make sure I don't like them. We have muscadine wine here in South Carolina and it's the nastiest tasting wine ever had. But I wanted to make sure I hated it so I drank a whole glass instead of just a sip. Yes I really do hate muscadine wine