mirror/JUCE
1
0
Fork 0
mirror of https://github.com/juce-framework/JUCE.git synced 2026-01-28 02:30:05 +00:00
Code Activity

BLOCKS API: Added support for custom block names

Browse source
This commit is contained in:
jules 2017-06-20 12:12:49 +01:00
parent 21f14c478b
commit 13b20de150
10 changed files with 629 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

4
modules/juce_blocks_basics/blocks/juce_Block.cpp
View file

@ -52,8 +52,8 @@ Block::Block (const juce::String& serial)
{
}
Block::Block (const juce::String& serial, const juce::String& version)
: serialNumber (serial), versionNumber (version), uid (getBlockUIDFromSerialNumber (serial))
Block::Block (const juce::String& serial, const juce::String& version, const juce::String& blockName)
: serialNumber (serial), versionNumber (version), name (blockName), uid (getBlockUIDFromSerialNumber (serial))
{
}

14
modules/juce_blocks_basics/blocks/juce_Block.h
View file

@ -62,6 +62,9 @@ public:
/** The Block's version number */
juce::String versionNumber;
/** The Block's name */
juce::String name;
using UID = uint64;
/** This Block's UID.
@ -371,6 +374,15 @@ public:
/** Reset all items active status */
virtual void resetConfigListActiveStatus() = 0;
/** Perform factory reset on Block */
virtual void factoryReset() = 0;
/** Reset this Block */
virtual void blockReset() = 0;
/** Set Block name */
virtual bool setName (const juce::String& name) = 0;
//==============================================================================
/** Allows the user to provide a function that will receive log messages from the block. */
virtual void setLogger (std::function<void(const String&)> loggingCallback) = 0;
@ -410,7 +422,7 @@ public:
protected:
//==============================================================================
Block (const juce::String& serialNumberToUse);
Block (const juce::String& serial, const juce::String& version);
Block (const juce::String& serial, const juce::String& version, const juce::String& name);
juce::ListenerList<DataInputPortListener> dataInputPortListeners;
juce::ListenerList<ProgramEventListener> programEventListeners;

18
modules/juce_blocks_basics/blocks/juce_BlockConfigManager.h
View file

@ -73,16 +73,16 @@ struct BlockConfigManager
ConfigDescription configList[numConfigItems] =
{
{ midiStartChannel, 1, 0, 15, false, "MIDI Start Channel", ConfigType::integer, {}, "MIDI Settings" },
{ midiEndChannel, 15, 0, 15, false, "MIDI End Channel", ConfigType::integer, {}, "MIDI Settings" },
{ midiStartChannel, 2, 1, 16, false, "MIDI Start Channel", ConfigType::integer, {}, "MIDI Settings" },
{ midiEndChannel, 16, 1, 16, false, "MIDI End Channel", ConfigType::integer, {}, "MIDI Settings" },
{ midiUseMPE, 1, 0, 1, false, "Use MPE", ConfigType::boolean, {}, "MIDI Settings" },
{ pitchBendRange, 48, 1, 96, false, "Pitch Bend Range", ConfigType::integer, {}, "MIDI Settings" },
{ octave, 0, -4, 6, false, "Octave", ConfigType::integer, {}, "Pitch" },
{ transpose, 0, -11, 11, false, "Transpose", ConfigType::integer, {}, "Pitch" },
{ slideCC, 74, 0, 127, false, "Slide CC", ConfigType::integer, {}, "5D Touch" },
{ slideCC, 74, 0, 127, false, "Slide CC", ConfigType::integer, {}, "Play mode" },
{ slideMode, 0, 0, 2, false, "Slide Mode", ConfigType::options, { "Absolute",
"Relative Unipolar",
"Relative Bipolar" }, "5D Touch" },
"Relative Bipolar" }, "Play mode" },
{ velocitySensitivity, 100, 0, 127, false, "Strike Sensitivity", ConfigType::integer, {}, "5D Touch" },
{ glideSensitivity, 100, 0, 127, false, "Glide Sensitivity", ConfigType::integer, {}, "5D Touch" },
{ slideSensitivity, 100, 0, 127, false, "Slide Sensitivity", ConfigType::integer, {}, "5D Touch" },
@ -90,8 +90,8 @@ struct BlockConfigManager
{ liftSensitivity, 100, 0, 127, false, "Lift Sensitivity", ConfigType::integer, {}, "5D Touch" },
{ fixedVelocity, 0, 0, 1, false, "Fixed Velocity", ConfigType::boolean, {}, "5D Touch" },
{ fixedVelocityValue, 127, 1, 127, false, "Fixed Velocity Value", ConfigType::integer, {}, "5D Touch" },
{ pianoMode, 0, 0, 1, false, "Piano Mode", ConfigType::boolean, {}, "5D Touch" },
{ glideLock, 0, 0, 127, false, "Glide Lock", ConfigType::integer, {}, "Play mode" },
{ pianoMode, 0, 0, 1, false, "Piano Mode", ConfigType::boolean, {}, "Play mode" },
{ glideLock, 0, 0, 127, false, "Glide Rate", ConfigType::integer, {}, "Play mode" },
{ mode, 4, 1, 5, false, "Mode", ConfigType::integer, {}, "Play mode" },
{ volume, 100, 0, 127, false, "Volume", ConfigType::integer, {}, "Play mode" },
{ scale, 0, 0, 18, false, "Scale", ConfigType::integer, {}, "Play mode" }, // NOTE: Should be options
@ -103,18 +103,18 @@ struct BlockConfigManager
"Last Played",
"Highest",
"Lowest",
"Disabled" }, "5D Touch" },
"Disabled" }, "Play mode" },
{ yTrackingMode, 1, 0, 4, false, "Slide Tracking Mode", ConfigType::options, { "Multi-Channel",
"Last Played",
"Highest",
"Lowest",
"Disabled" }, "5D Touch" },
"Disabled" }, "Play mode" },
{ zTrackingMode, 1, 0, 4, false, "Pressure Tracking Mode", ConfigType::options, { "Multi-Channel",
"Last Played",
"Highest",
"Lowest",
"Disabled",
"Hardest" }, "5D Touch" },
"Hardest" }, "Play mode" },
// These can be defined for unique usage for a given Littlefoot script
{ user0, 0, 0, 127, false, {}, ConfigType::integer, {}, {} },
{ user1, 0, 0, 127, false, {}, ConfigType::integer, {}, {} },

6
modules/juce_blocks_basics/protocol/juce_BlockModels.h
View file

@ -208,8 +208,10 @@ private:
lightGridWidth = 0;
lightGridHeight = 0;
numKeywaves = 24;
addPorts (2, 1, 0, 1);
addPortsSW (Block::ConnectionPort::DeviceEdge::west, 1);
addPortsNE (Block::ConnectionPort::DeviceEdge::north, 2);
addPortsNE (Block::ConnectionPort::DeviceEdge::east, 1);
hasTouchSurface = true;
programAndHeapSize = BlocksProtocol::padBlockProgramAndHeapSize;

20
modules/juce_blocks_basics/protocol/juce_BlocksProtocolDefinitions.h
View file

@ -48,6 +48,7 @@ enum class MessageFromDevice
deviceTopologyExtend = 0x04,
deviceTopologyEnd = 0x05,
deviceVersionList = 0x06,
deviceNameList = 0x07,
touchStart = 0x10,
touchMove = 0x11,
@ -75,7 +76,11 @@ enum class MessageFromHost
programEventMessage = 0x03,
firmwareUpdatePacket = 0x04,
configMessage = 0x10
configMessage = 0x10,
factoryReset = 0x11,
blockReset = 0x12,
setName = 0x20
};
@ -146,6 +151,12 @@ struct VersionNumber
uint8 length = 0;
};
struct BlockName
{
uint8 name[33] = {};
uint8 length = 0;
};
struct DeviceStatus
{
BlockSerialNumber serialNumber;
@ -166,6 +177,12 @@ struct DeviceVersion
VersionNumber version;
};
struct DeviceName
{
TopologyIndex index;
BlockName name;
};
static constexpr uint8 maxBlocksInTopologyPacket = 6;
static constexpr uint8 maxConnectionsInTopologyPacket = 24;
@ -425,6 +442,7 @@ static constexpr const char* ledProgramLittleFootFunctions[] =
"getNumBlocksInCurrentCluster/i",
"getBlockIdForBlockInCluster/ii",
"isMasterInCurrentCluster/b",
"setClusteringActive/vb",
"makeARGB/iiiii",
"blendARGB/iii",
"fillPixel/viii",

54
modules/juce_blocks_basics/protocol/juce_HostPacketBuilder.h
View file

@ -227,15 +227,21 @@ struct HostPacketBuilder
//==============================================================================
bool addConfigSetMessage (int32 item, int32 value)
{
writeMessageType (MessageFromHost::configMessage);
if (! data.hasCapacity (BitSizes::configSetMessage))
return false;
writeMessageType(MessageFromHost::configMessage);
ConfigCommand type = ConfigCommands::setConfig;
data << type << IntegerWithBitSize<8> ((uint32) item) << IntegerWithBitSize<32> ((uint32) value);
data << type << IntegerWithBitSize<8> ((uint32) item) << IntegerWithBitSize<32>((uint32) value);
return true;
}
bool addRequestMessage (int32 item)
{
writeMessageType (MessageFromHost::configMessage);
if (! data.hasCapacity (BitSizes::configSetMessage))
return false;
writeMessageType(MessageFromHost::configMessage);
ConfigCommand type = ConfigCommands::requestConfig;
data << type << IntegerWithBitSize<32> (0) << IntegerWithBitSize<8> ((uint32) item);
return true;
@ -243,6 +249,9 @@ struct HostPacketBuilder
bool addRequestFactorySyncMessage()
{
if (! data.hasCapacity (MessageType::bits + ConfigCommand::bits))
return false;
writeMessageType (MessageFromHost::configMessage);
ConfigCommand type = ConfigCommands::requestFactorySync;
data << type;
@ -251,12 +260,51 @@ struct HostPacketBuilder
bool addRequestUserSyncMessage()
{
if (! data.hasCapacity (MessageType::bits + ConfigCommand::bits))
return false;
writeMessageType (MessageFromHost::configMessage);
ConfigCommand type = ConfigCommands::requestUserSync;
data << type;
return true;
}
//==============================================================================
bool addFactoryReset()
{
if (! data.hasCapacity (MessageType::bits))
return false;
writeMessageType(MessageFromHost::factoryReset);
return true;
}
bool addBlockReset()
{
if (! data.hasCapacity (MessageType::bits))
return false;
writeMessageType(MessageFromHost::blockReset);
return true;
}
bool addSetBlockName (const juce::String& name)
{
if (name.length() > 32 || ! data.hasCapacity (MessageType::bits + 7 + (7 * name.length())))
return false;
writeMessageType (MessageFromHost::setName);
data << IntegerWithBitSize<7> ((uint32) name.length());
for (auto i = 0; i < name.length(); ++i)
data << IntegerWithBitSize<7> ((uint32) name.toRawUTF8()[i]);
data << IntegerWithBitSize<7> (0);
return true;
}
//==============================================================================
private:
Packed7BitArrayBuilder<maxPacketBytes> data;

15
modules/juce_blocks_basics/protocol/juce_HostPacketDecoder.h
View file

@ -65,6 +65,7 @@ struct HostPacketDecoder
case MessageFromDevice::deviceTopologyExtend: return handleTopology (handler, reader, false);
case MessageFromDevice::deviceTopologyEnd: return handleTopologyEnd (handler, reader);
case MessageFromDevice::deviceVersionList: return handleVersion (handler, reader);
case MessageFromDevice::deviceNameList: return handleName (handler, reader);
case MessageFromDevice::touchStart: return handleTouch (handler, reader, deviceIndex, packetTimestamp, true, false);
case MessageFromDevice::touchMove: return handleTouch (handler, reader, deviceIndex, packetTimestamp, false, false);
case MessageFromDevice::touchEnd: return handleTouch (handler, reader, deviceIndex, packetTimestamp, false, true);
@ -184,6 +185,20 @@ struct HostPacketDecoder
return true;
}
static bool handleName (Handler& handler, Packed7BitArrayReader& reader)
{
DeviceName name;
name.index = (TopologyIndex) reader.readBits (topologyIndexBits);
name.name.length = (uint8) reader.readBits (7);
for (uint32 i = 0; i < name.name.length; ++i)
name.name.name[i] = (uint8) reader.readBits (7);
handler.handleName (name);
return true;
}
static bool handleTouch (Handler& handler, Packed7BitArrayReader& reader, TopologyIndex deviceIndex,
PacketTimestamp packetTimestamp, bool isStart, bool isEnd)
{

122
modules/juce_blocks_basics/topology/juce_PhysicalTopologySource.cpp
View file

@ -310,6 +310,7 @@ struct PhysicalTopologySource::Internal
BlocksProtocol::TopologyIndex index;
BlocksProtocol::BlockSerialNumber serial;
BlocksProtocol::VersionNumber version;
BlocksProtocol::BlockName name;
bool isMaster;
};
@ -326,11 +327,13 @@ struct PhysicalTopologySource::Internal
for (auto& device : devices)
{
BlocksProtocol::VersionNumber version;
BlocksProtocol::BlockName name;
result.add ({ getBlockUIDFromSerialNumber (device.serialNumber),
device.index,
device.serialNumber,
version,
name,
isFirst });
isFirst = false;
@ -367,6 +370,15 @@ struct PhysicalTopologySource::Internal
return false;
}
static bool nameAddedToBlock (const juce::Array<DeviceInfo>& devices, Block::UID uid) noexcept
{
for (auto&& d : devices)
if (d.uid == uid && d.name.length)
return true;
return false;
}
static void setVersionNumberForBlock (const juce::Array<DeviceInfo>& devices, Block& block) noexcept
{
for (auto&& d : devices)
@ -374,6 +386,13 @@ struct PhysicalTopologySource::Internal
block.versionNumber = juce::String ((const char*) d.version.version, d.version.length);
}
static void setNameForBlock (const juce::Array<DeviceInfo>& devices, Block& block) noexcept
{
for (auto&& d : devices)
if (d.uid == block.uid)
block.name = juce::String ((const char*) d.name.name, d.name.length);
}
//==============================================================================
struct ConnectedDeviceGroup : private juce::AsyncUpdater,
private juce::Timer
@ -519,13 +538,30 @@ struct PhysicalTopologySource::Internal
void handleVersion (BlocksProtocol::DeviceVersion version)
{
for (auto& d : currentDeviceInfo)
for (auto i = 0; i < currentDeviceInfo.size(); ++i)
{
if (d.index == version.index)
if (currentDeviceInfo[i].index == version.index && version.version.length > 1)
{
d.version = version.version;
detector.handleTopologyChange();
return;
if (memcmp (currentDeviceInfo.getReference (i).version.version, version.version.version, sizeof (version.version)))
{
currentDeviceInfo.getReference(i).version = version.version;
detector.handleTopologyChange();
}
}
}
}
void handleName (BlocksProtocol::DeviceName name)
{
for (auto i = 0; i < currentDeviceInfo.size(); ++i)
{
if (currentDeviceInfo[i].index == name.index && name.name.length > 1)
{
if (memcmp (currentDeviceInfo.getReference (i).name.name, name.name.name, sizeof (name.name)))
{
currentDeviceInfo.getReference (i).name = name.name;
detector.handleTopologyChange();
}
}
}
}
@ -886,16 +922,20 @@ struct PhysicalTopologySource::Internal
currentTopology.blocks.remove (i);
}
else if (versionNumberAddedToBlock (newDeviceInfo, block->uid, block->versionNumber))
else
{
setVersionNumberForBlock (newDeviceInfo, *block);
if (versionNumberAddedToBlock (newDeviceInfo, block->uid, block->versionNumber))
setVersionNumberForBlock (newDeviceInfo, *block);
if (nameAddedToBlock (newDeviceInfo, block->uid))
setNameForBlock (newDeviceInfo, *block);
}
}
for (auto& info : newDeviceInfo)
if (info.serial.isValid())
if (! containsBlockWithUID (currentTopology.blocks, getBlockUIDFromSerialNumber (info.serial)))
currentTopology.blocks.add (new BlockImplementation (info.serial, *this, info.version, info.isMaster));
currentTopology.blocks.add (new BlockImplementation (info.serial, *this, info.version, info.name, info.isMaster));
currentTopology.connections.swapWith (newDeviceConnections);
}
@ -1154,9 +1194,10 @@ struct PhysicalTopologySource::Internal
private MIDIDeviceConnection::Listener,
private Timer
{
BlockImplementation (const BlocksProtocol::BlockSerialNumber& serial, Detector& detectorToUse, BlocksProtocol::VersionNumber version, bool master)
BlockImplementation (const BlocksProtocol::BlockSerialNumber& serial, Detector& detectorToUse, BlocksProtocol::VersionNumber version, BlocksProtocol::BlockName name, bool master)
: Block (juce::String ((const char*) serial.serial, sizeof (serial.serial)),
juce::String ((const char*) version.version, version.length)),
juce::String ((const char*) version.version, version.length),
juce::String ((const char*) name.name, name.length)),
modelData (serial),
remoteHeap (modelData.programAndHeapSize),
detector (detectorToUse),
@ -1615,6 +1656,67 @@ struct PhysicalTopologySource::Internal
configChangedCallback = configChanged;
}
void factoryReset() override
{
auto index = getDeviceIndex();
if (index >= 0)
{
BlocksProtocol::HostPacketBuilder<32> p;
p.writePacketSysexHeaderBytes ((BlocksProtocol::TopologyIndex) index);
p.addFactoryReset();
p.writePacketSysexFooter();
sendMessageToDevice (p);
}
else
{
jassertfalse;
}
}
void blockReset() override
{
auto index = getDeviceIndex();
if (index >= 0)
{
BlocksProtocol::HostPacketBuilder<32> p;
p.writePacketSysexHeaderBytes ((BlocksProtocol::TopologyIndex) index);
p.addBlockReset();
p.writePacketSysexFooter();
sendMessageToDevice (p);
}
else
{
jassertfalse;
}
}
bool setName (const juce::String& name) override
{
auto index = getDeviceIndex();
if (index >= 0)
{
BlocksProtocol::HostPacketBuilder<128> p;
p.writePacketSysexHeaderBytes ((BlocksProtocol::TopologyIndex) index);
if (p.addSetBlockName (name))
{
p.writePacketSysexFooter();
if (sendMessageToDevice (p))
return true;
}
}
else
{
jassertfalse;
}
return false;
}
//==============================================================================
std::unique_ptr<TouchSurface> touchSurface;
juce::OwnedArray<ControlButton> controlButtons;

402
modules/juce_blocks_basics/visualisers/juce_DrumPadLEDProgram.cpp
View file

@ -160,6 +160,402 @@ void DrumPadGridProgram::resumeAnimations()
//==============================================================================
juce::String DrumPadGridProgram::getLittleFootProgram()
{
if (block.versionNumber.isEmpty() || block.versionNumber.compare ("0.2.5") < 0)
return getLittleFootProgramPre25();
return getLittleFootProgramPost25();
}
juce::String DrumPadGridProgram::getLittleFootProgramPre25() const
{
// Uses its own heatmap, not the one provided in newer firmware
// Also can't use blocks config, introduced in 2.5.
return R"littlefoot(
#heapsize: 1351
int dimFactor;
int dimDelay;
int slideAnimationProgress;
int lastVisiblePads;
int getGridColour (int index, int colourMapOffset)
{
int bit = (2 + colourMapOffset) * 8 + index * 16;
return makeARGB (255,
getHeapBits (bit, 5) << 3,
getHeapBits (bit + 5, 6) << 2,
getHeapBits (bit + 11, 5) << 3);
}
// Returns the current progress and also increments it for next frame
int getAnimationProgress (int index)
{
// Only 16 animated pads supported
if (index > 15)
return 0;
int offsetBits = 162 * 8 + index * 32;
int currentProgress = getHeapBits (offsetBits, 16);
int increment = getHeapBits (offsetBits + 16, 16);
int nextFrame = currentProgress + increment;
// Set incremented 16 bit number.
setHeapByte (162 + index * 4, nextFrame & 0xff);
setHeapByte (163 + index * 4, nextFrame >> 8);
return currentProgress;
}
void outlineRect (int colour, int x, int y, int w)
{
fillRect (colour, x, y, w, 1);
fillRect (colour, x, y + w - 1, w, 1);
fillRect (colour, x, y + 1, 1, w - 1);
fillRect (colour, x + w - 1, y + 1, 1, w - 1);
}
void drawPlus (int colour, int x, int y, int w)
{
fillRect (colour, x, y + (w / 2), w, 1);
fillRect (colour, x + (w / 2), y, 1, w);
}
void fillGradientRect (int colour, int x, int y, int w)
{
if (colour != 0xff000000)
{
int divisor = w + w - 1;
for (int yy = 0; yy < w; ++yy)
{
for (int xx = yy; xx < w; ++xx)
{
int gradColour = blendARGB (colour, makeARGB (((xx + yy) * 250) / divisor, 0, 0, 0));
setLED (x + xx, y + yy, gradColour);
setLED (x + yy, y + xx, gradColour);
}
}
}
}
// TODO: Tom M: This is massaged to work with 3x3 pads and for dots to sync
// with Apple POS loop length. Rework to be more robust & flexible.
void drawPizzaLED (int colour, int x, int y, int w, int progress)
{
--w;
x += 1;
int numToDo = ((8 * progress) / 255) + 1;
int totalLen = w * 4;
for (int i = 1; i <= numToDo; ++i)
{
setLED (x, y, colour);
if (i < w)
++x;
else if (i < (w * 2))
++y;
else if (i < (w * 3))
--x;
else if (i < totalLen)
--y;
}
}
void drawPad (int padX, int padY, int padW,
int colour, int fill, int animateProgress)
{
animateProgress >>= 8; // 16 bit to 8 bit
int halfW = padW / 2;
if (fill == 0) // Gradient fill
{
fillGradientRect (colour, padX, padY, padW);
}
else if (fill == 1) // Filled
{
fillRect (colour, padX, padY, padW, padW);
}
else if (fill == 2) // Hollow
{
outlineRect (colour, padX, padY, padW);
}
else if (fill == 3) // Hollow with plus
{
outlineRect (colour, padX, padY, padW);
drawPlus (0xffffffff, padX, padY, padW);
}
else if (fill == 4) // Pulsing dot
{
int pulseCol = blendARGB (colour, makeARGB (animateProgress, 0, 0, 0));
setLED (padX + halfW, padY + halfW, pulseCol);
}
else if (fill == 5) // Blinking dot
{
int blinkCol = animateProgress > 64 ? makeARGB (255, 0, 0, 0) : colour;
setLED (padX + halfW, padY + halfW, blinkCol);
}
else if (fill == 6) // Pizza filled
{
outlineRect (blendARGB (colour, makeARGB (220, 0, 0, 0)), padX, padY, padW); // Dim outline
setLED (padX + halfW, padY + halfW, colour); // Bright centre
drawPizzaLED (colour, padX, padY, padW, animateProgress);
}
else if (fill == 7) // Pizza hollow
{
outlineRect (blendARGB (colour, makeARGB (220, 0, 0, 0)), padX, padY, padW); // Dim outline
drawPizzaLED (colour, padX, padY, padW, animateProgress);
return;
}
}
void fadeHeatMap()
{
for (int i = 0; i < 225; ++i)
{
int colourOffset = 226 + i * 4;
int colour = getHeapInt (colourOffset);
int alpha = (colour >> 24) & 0xff;
if (alpha > 0)
{
alpha -= getHeapByte (1126 + i);
setHeapInt (colourOffset, alpha < 0 ? 0 : ((alpha << 24) | (colour & 0xffffff)));
}
}
}
void addToHeatMap (int x, int y, int colour)
{
if (x >= 0 && y >= 0 && x < 15 && y < 15)
{
int offset = 226 + 4 * (x + y * 15);
colour = blendARGB (getHeapInt (offset), colour);
setHeapInt (offset, colour);
int decay = ((colour >> 24) & 0xff) / 14; // change divisor to change trail times
offset = 1126 + (x + y * 15);
setHeapByte (offset, decay > 0 ? decay : 1);
}
}
int getHeatmapColour (int x, int y)
{
return getHeapInt (226 + 4 * (x + y * 15));
}
int isPadActive (int index)
{
if (getHeapInt (158) == 0) // None active
return 0;
++index;
return index == getHeapByte (158) ||
index == getHeapByte (159) ||
index == getHeapByte (160) ||
index == getHeapByte (161);
}
void updateDimFactor()
{
if (getHeapInt (158) == 0)
{
if (--dimDelay <= 0)
{
dimFactor -= 12;
if (dimFactor < 0)
dimFactor = 0;
}
}
else
{
dimFactor = 180;
dimDelay = 12;
}
}
void drawPads (int offsetX, int offsetY, int colourMapOffset)
{
int padsPerSide = getHeapByte (0 + colourMapOffset);
if (padsPerSide < 2)
return;
int blockW = 15 / padsPerSide;
int blockPlusGapW = blockW + (15 - padsPerSide * blockW) / (padsPerSide - 1);
for (int padY = 0; padY < padsPerSide; ++padY)
{
for (int padX = 0; padX < padsPerSide; ++padX)
{
int ledX = offsetX + padX * blockPlusGapW;
int ledY = offsetY + padY * blockPlusGapW;
if (ledX < 15 &&
ledY < 15 &&
(ledX + blockW) >= 0 &&
(ledY + blockW) >= 0)
{
int padIdx = padX + padY * padsPerSide;
bool padActive = isPadActive (padIdx);
int blendCol = padActive ? 255 : 0;
int blendAmt = padActive ? dimFactor >> 1 : dimFactor;
int colour = blendARGB (getGridColour (padIdx, colourMapOffset),
makeARGB (blendAmt, blendCol, blendCol, blendCol));
int fillType = getHeapByte (colourMapOffset + 52 + padIdx);
int animate = getAnimationProgress (padIdx);
drawPad (ledX, ledY, blockW, colour, fillType, animate);
}
}
}
}
void slideAnimatePads()
{
int nowVisible = getHeapByte (155);
if (lastVisiblePads != nowVisible)
{
lastVisiblePads = nowVisible;
if (slideAnimationProgress <= 0)
slideAnimationProgress = 15;
}
// If animation is complete, draw normally.
if (slideAnimationProgress <= 0)
{
drawPads (0, 0, 78 * nowVisible);
slideAnimationProgress = 0;
}
else
{
int direction = getHeapByte (156);
slideAnimationProgress -= 1;
int inPos = nowVisible == 0 ? 0 : 78;
int outPos = nowVisible == 0 ? 78 : 0;
if (direction == 0) // Up
{
drawPads (0, slideAnimationProgress - 16, outPos);
drawPads (0, slideAnimationProgress, inPos);
}
else if (direction == 1) // Down
{
drawPads (0, 16 - slideAnimationProgress, outPos);
drawPads (0, 0 - slideAnimationProgress, inPos);
}
else if (direction == 2) // Left
{
drawPads (16 - slideAnimationProgress, 0, outPos);
drawPads (slideAnimationProgress, 0, inPos);
}
else if (direction == 3) // Right
{
drawPads (16 - slideAnimationProgress, 0, outPos);
drawPads (0 - slideAnimationProgress, 0, inPos);
}
else // None
{
drawPads (0, 0, 78 * nowVisible);
slideAnimationProgress = 0;
}
}
}
void repaint()
{
// showErrorOnFail, showRepaintTime, showMovingDot
//enableDebug (true, true, false);
// Clear LEDs to black, update dim animation
fillRect (0xff000000, 0, 0, 15, 15);
updateDimFactor();
// Does the main painting of pads
slideAnimatePads();
// Overlay heatmap
for (int y = 0; y < 15; ++y)
for (int x = 0; x < 15; ++x)
blendLED (x, y, getHeatmapColour (x, y));
fadeHeatMap();
}
// DrumPadGridProgram::sendTouch results in this callback, giving
// us more touch updates per frame and therefore smoother trails.
void handleMessage (int pos, int colour, int xx)
{
handleMessage (pos, colour);
}
void handleMessage (int pos, int colour)
{
if ((pos >> 24) != 0x20)
return;
int tx = ((pos >> 16) & 0xff) - 13;
int ty = ((pos >> 8) & 0xff) - 13;
int tz = pos & 0xff;
tz = tz > 30 ? tz : 30;
int ledCentreX = tx >> 4;
int ledCentreY = ty >> 4;
int adjustX = (tx - (ledCentreX << 4)) >> 2;
int adjustY = (ty - (ledCentreY << 4)) >> 2;
for (int dy = -2; dy <= 2; ++dy)
{
for (int dx = -2; dx <= 2; ++dx)
{
int distance = dx * dx + dy * dy;
int level = distance == 0 ? 255 : (distance == 1 ? 132 : (distance < 5 ? 9 : (distance == 5 ? 2 : 0)));
level += (dx * adjustX);
level += (dy * adjustY);
level = (tz * level) >> 8;
if (level > 0)
addToHeatMap (ledCentreX + dx, ledCentreY + dy,
makeARGB (level, colour >> 16, colour >> 8, colour));
}
}
}
)littlefoot";
}
juce::String DrumPadGridProgram::getLittleFootProgramPost25() const
{
// Uses heatmap provided in firmware (so the program's smaller)
// Initialises config items introduced in firmware 2.5
return R"littlefoot(
#heapsize: 256
@ -169,6 +565,12 @@ juce::String DrumPadGridProgram::getLittleFootProgram()
int slideAnimationProgress;
int lastVisiblePads;
void initialise()
{
for (int i = 0; i < 32; ++i)
setLocalConfigActiveState (i, true, true);
}
int getGridColour (int index, int colourMapOffset)
{
int bit = (2 + colourMapOffset) * 8 + index * 16;

2
modules/juce_blocks_basics/visualisers/juce_DrumPadLEDProgram.h
View file

@ -115,4 +115,6 @@ private:
void setGridFills (int numColumns, int numRows, const juce::Array<GridFill>& fills, uint32 byteOffset);
juce::String getLittleFootProgram() override;
juce::String getLittleFootProgramPre25() const;
juce::String getLittleFootProgramPost25() const;
};