@dpantani/tdmcp 0.1.0

package/dist/knowledge/data/tutorials/anatomy_of_a_chop.json

@@ -0,0 +1,275 @@
+{
+  "id": "anatomy_of_a_chop",
+  "name": "Anatomy of a CHOP",
+  "displayName": "Anatomy of a CHOP",
+  "category": "TUTORIAL",
+  "subcategory": "CHOP Tutorial",
+  "type": "tutorial",
+  "description": "Parameters of SOPs, TOPs and objects (components) are able to get values from CHOP channels with expressions like the following:",
+  "summary": "Parameters of SOPs, TOPs and objects (components) are able to get values from CHOP channels with expressions like the following: However, exporting is preferred where possible. It is faster and involves less typing.",
+  "content": {
+    "sections": [
+      {
+        "title": "Inside a CHOP",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "A CHOP contains a set of channels defined over a start-end interval.",
+              "The channels of a CHOP can represent motion, MIDI, audio, color maps, rolloff curves or lookup tables.",
+              "Each channel is one array of raw samples, which is simply a list of numbers.",
+              "Each channel of a CHOP has a channel name that can be set by the user.",
+              "The group of CHOP channels is known as a clip.",
+              "A CHOP contains a clip plus control parameters, a sample rate, some on/off flags, and a start/end interval.",
+              "The CHOP can have any start/end indexes. All channels in a CHOP share the same start-end interval.",
+              "The interval goes from the start position to the end position.",
+              "The interval of a CHOP is not restricted to be the length of the animation.",
+              "Each CHOP has a sample rate, used if the CHOP contains time-dependent motion or audio data.",
+              "Audio has a high sample rates when compared to animated motion."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "CHOP Inputs, Parameters and Outputs",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "CHOPs have \"parameters\" used to define the data, plus the data channels, which are input/output from the CHOP as its data stream.",
+              "The CHOP parameters are usually constant-valued, but can be time-dependent expressions.",
+              "Each CHOP receives channels at its inputs. When the CHOP cooks, the channels of the inputs are combined. The CHOP outputs the resulting channels to other CHOPs.",
+              "CHOPs output their data channels as arrays of numbers, not interpolated segments. Some CHOPs retain interpolated segments internally, but all CHOPs always output their data as raw samples.",
+              "If the CHOP's inputs are not changing and the control parameters are not time-dependent, the CHOP will be non-time-dependent and it will not cook every time the animation frame advances.",
+              "Some CHOPs have Local Variables: $I (the array index within the CHOP), $C (the channel number within the CHOP)",
+              "Some CHOPs output or use CHOP attributes, such as channels grouped as quaternion rotation channels."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Parts of a CHOP",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "Each CHOP has a set of parameters.",
+              "CHOPs' parameters can be expressed in different units: samples (indexes), frames or seconds. These units are selected by the user in a menu to the right of such parameters.",
+              "Each CHOP has flags: The Graph flag marks the CHOP to be displayed in the Graph of the CHOP Editor. The Export flag causes the CHOP channels to override channels of objects, SOps. The Lock flag causes the CHOP can be locked and hand-edited. The Channel Editor is the interactive editor of parameter channels in CHOPs. The Bypass flag is a convenient way for a CHOP's effect to be disabled.",
+              "The Graph flag marks the CHOP to be displayed in the Graph of the CHOP Editor.",
+              "The Export flag causes the CHOP channels to override channels of objects, SOps.",
+              "The Lock flag causes the CHOP can be locked and hand-edited. The Channel Editor is the interactive editor of parameter channels in CHOPs.",
+              "The Bypass flag is a convenient way for a CHOP's effect to be disabled.",
+              "Each CHOP has an info pop-up menu accessible by middle-mouse clicking on the CHOP. This lists channel names and values, sample rate and interval.",
+              "Each CHOP has a comment field."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "CHOP Networks",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "CHOPs are arranged in OP networks in components, where CHOP outputs are connected to the inputs of other CHOPs."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Importing / Exporting CHOP Channels",
+        "level": 2,
+        "content": [
+          {
+            "type": "subsection",
+            "title": "Object, SOP and COP Channels Imported from CHOPs",
+            "level": 3
+          },
+          {
+            "type": "paragraph",
+            "text": "Parameters of SOPs, TOPs and objects (components) are able to get values from CHOP channels with expressions like the following:"
+          },
+          {
+            "type": "code",
+            "text": "chop(CHOPchannelpath)\n chopi(CHOPchannelpath, index",
+            "language": "python"
+          },
+          {
+            "type": "paragraph",
+            "text": "However, exporting is preferred where possible. It is faster and involves less typing."
+          },
+          {
+            "type": "subsection",
+            "title": "CHOPs Exported to Component, SOP and TOP Channels",
+            "level": 3
+          },
+          {
+            "type": "unordered-list",
+            "items": [
+              "CHOP data channels are exported to Components, SOPs, etc. to drive their parameters. CHOPs can be exported to any TouchDesigner parameter.",
+              "Each CHOP has an Export flag (and an Export Prefix, infrequently used), causing the CHOP to attach its channels to Components, SOPs, TOPs and so on.",
+              "The Export flag and Export Prefix are used to connect channels of an object or SOP directly to a CHOP. It uses automatic matching of channels names. For example, a CHOP \"tx\" channel could map to an Geometry Component's tx parameter.",
+              "When a CHOP exports to an object, SOP or TOP, the latters' channels are said to be overridden. An OP's Override menu lists what is overridden."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Channel Index and Value",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "The horizontal axis is called the i-axis or the index-axis.",
+              "The vertical axis is called the v-axis or the value-axis.",
+              "An index is a point along the i-axis,denoted by i.",
+              "A value is a point along the v-axis, denoted by v.",
+              "A sample is an index-value pair (i,v). i.e. the value of a channel at a certain index.",
+              "A sample is made of a sample index and a sample value.",
+              "An interval is an index range, which goes from a start index to an end index.",
+              "A value range goes from a start value to an end value.",
+              "The index duration is the end index minus the start index + 1.",
+              "CHOP data channels are arrays of raw samples, in 32-bit floating point format.",
+              "Channels in a CHOP may be control (parameter) channels or data channels. CHOPs manupulate the data channels.",
+              "CHOPs can be evaluated at integer and non-integer indexes.",
+              "Frame is used when the index corresponds to time.",
+              "When speaking of animation frames, you can refer to start frame, end frame and frame range."
+            ]
+          }
+        ]
+      },
+      {
+        "title": "CHOPs for Audio",
+        "level": 2,
+        "content": [
+          {
+            "type": "unordered-list",
+            "items": [
+              "Audio File In CHOP",
+              "Audio Movie CHOP",
+              "Audio Play CHOP",
+              "Audio Device In CHOP",
+              "Audio Device Out CHOP"
+            ]
+          }
+        ]
+      }
+    ],
+    "tableOfContents": [
+      {
+        "number": "1",
+        "text": "Inside a CHOP",
+        "href": "#Inside_a_CHOP"
+      },
+      {
+        "number": "2",
+        "text": "CHOP Inputs, Parameters and Outputs",
+        "href": "#CHOP_Inputs,_Parameters_and_Outputs"
+      },
+      {
+        "number": "3",
+        "text": "Parts of a CHOP",
+        "href": "#Parts_of_a_CHOP"
+      },
+      {
+        "number": "4",
+        "text": "CHOP Networks",
+        "href": "#CHOP_Networks"
+      },
+      {
+        "number": "5",
+        "text": "Importing / Exporting CHOP Channels",
+        "href": "#Importing_/_Exporting_CHOP_Channels"
+      },
+      {
+        "number": "5.1",
+        "text": "Object, SOP and COP Channels Imported from CHOPs",
+        "href": "#Object,_SOP_and_COP_Channels_Imported_from_CHOPs"
+      },
+      {
+        "number": "5.2",
+        "text": "CHOPs Exported to Component, SOP and TOP Channels",
+        "href": "#CHOPs_Exported_to_Component,_SOP_and_TOP_Channels"
+      },
+      {
+        "number": "6",
+        "text": "Channel Index and Value",
+        "href": "#Channel_Index_and_Value"
+      },
+      {
+        "number": "7",
+        "text": "CHOPs for Audio",
+        "href": "#CHOPs_for_Audio"
+      }
+    ],
+    "relatedLinks": [
+      {
+        "text": "Audio File In CHOP",
+        "href": "Audio_File_In_CHOP.htm"
+      },
+      {
+        "text": "Audio Movie CHOP",
+        "href": "Audio_Movie_CHOP.htm"
+      },
+      {
+        "text": "Audio Play CHOP",
+        "href": "Audio_Play_CHOP.htm"
+      },
+      {
+        "text": "Audio Device In CHOP",
+        "href": "Audio_Device_In_CHOP.htm"
+      },
+      {
+        "text": "Audio Device Out CHOP",
+        "href": "Audio_Device_Out_CHOP.htm"
+      }
+    ],
+    "images": [
+      {
+        "src": "./images/2/2b/ChannelsInfo2.gif",
+        "alt": "ChannelsInfo2.gif",
+        "caption": ""
+      }
+    ]
+  },
+  "keywords": [
+    "anatomy",
+    "chop",
+    "inside",
+    "inputs,",
+    "parameters",
+    "outputs",
+    "parts",
+    "networks",
+    "importing",
+    "exporting",
+    "channels",
+    "channel",
+    "index",
+    "value",
+    "chops",
+    "audio",
+    "top",
+    "sop",
+    "comp",
+    "parameter",
+    "component",
+    "export"
+  ],
+  "tags": [
+    "Tutorial",
+    "TouchDesigner",
+    "Anatomy of a CHOP"
+  ],
+  "searchWeight": 2,
+  "lastUpdated": "2025-08-08T03:32:33.567Z",
+  "sourceFile": "C:\\Program Files\\Derivative\\TouchDesigner\\Samples\\Learn\\OfflineHelp\\https.docs.derivative.ca\\Anatomy_of_a_CHOP.htm",
+  "isValid": true,
+  "validationErrors": []
+}

package/dist/knowledge/data/tutorials/build_a_list_comp.json

@@ -0,0 +1,268 @@
+{
+  "id": "build_a_list_comp",
+  "name": "Build a List COMP",
+  "displayName": "Build a List COMP",
+  "category": "TUTORIAL",
+  "subcategory": "COMP Tutorial",
+  "type": "tutorial",
+  "description": "This document explains the finer points of building a List COMP. It is assumed the reader already has an understanding of the Python language. The official Python documentation can be found at this address.",
+  "summary": "This document explains the finer points of building a List COMP. It is assumed the reader already has an understanding of the Python language. The official Python documentation can be found at this address. The List COMP runs its init callbacks when the Reset parameter is pulsed or on load. These init functions are in place to let the user assign Table, Row, Col or Cell specific attributes which determine the layout and look of the List. The four init functions are called in this order: Once initialized the following callback functions are run on specific events:",
+  "content": {
+    "sections": [
+      {
+        "title": "Overview",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "This document explains the finer points of building a List COMP. It is assumed the reader already has an understanding of the Python language. The official Python documentation can be found at this address."
+          }
+        ]
+      },
+      {
+        "title": "Callbacks Stages",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "The List COMP runs its init callbacks when the Reset parameter is pulsed or on load. These init functions are in place to let the user assign Table, Row, Col or Cell specific attributes which determine the layout and look of the List. The four init functions are called in this order:"
+          },
+          {
+            "type": "unordered-list",
+            "items": [
+              "onInitTable(comp, attribs)",
+              "onInitCol(comp, col, attribs)",
+              "onInitRow(comp, row, attribs)",
+              "onInitCell(comp, row, col, attribs)"
+            ]
+          },
+          {
+            "type": "paragraph",
+            "text": "Once initialized the following callback functions are run on specific events:"
+          },
+          {
+            "type": "unordered-list",
+            "items": [
+              "onRollover(comp, row, col, coords, prevRow, prevCol, prevCoords) is called when a mouse rolls over a cell",
+              "onSelect(comp, startRow, startCol, startCoords, endRow, endCol, endCoords, start, end) is called when a mouse is clicked while over a cell",
+              "onRadio(comp, row, col, prevRow, prevCol)",
+              "onFocus(comp, row, col, prevRow, prevCol)",
+              "onEdit(comp, row, col, val)"
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Building a simple List COMP with a Folder DAT as content source",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "Lets assume you want to display the content of a Folder DAT with the ability to highlight rows you are rolling over. Lets also assume that clicking on a row will change the rows layout as well and run a custom script which takes the row and column as an argument. As a requirement, the first row should act as a header row with a different layout then the rest. For this example it is assumed that the Folder DAT is 5 columns wide and located parallel to the List COMP."
+          },
+          {
+            "type": "paragraph",
+            "text": "When dealing with the List COMP you have to be aware of the fact that its flexibility comes with a responsibility of the creator to manage states as well. This means that while List COMP is running callbacks as mentioned earlier, you will have to make sure that you save the Lists current state in appropriate ways. For example when a row changes its layout on rollover, the callbacks will have to make sure to change the layout back to its default look once the mouse leaves the row. Its proven very useful to save the required states in Python lists or dictionaries as Storage"
+          },
+          {
+            "type": "paragraph",
+            "text": "In the List COMP parameters on the List page, change the Rows and Columns parameter to reflect the Folder DAT size and enable the Lock First Row parameter. On the Layout parameter page, change the Width parameter to 900."
+          },
+          {
+            "type": "paragraph",
+            "text": "Enter the List COMP and start editing the callbacks Text DAT. For the initRow function enter this to specify each rows bgColor and hit the List COMP Reset parameter to see the changes:"
+          },
+          {
+            "type": "code",
+            "text": "def onInitRow(comp, row, attribs):\n\t# if this is the first row make the background slightly red, otherwise keep it grey\n\tif row == 0:\n\t\tbgColor = [0.4,0.2,0.2,1]\n\telse:\n\t\tbgColor = [0.2,0.2,0.2,1]\n\n\t# assign the bgColor to the rows attributes\n\tattribs.bgColor = bgColor\n\n\treturn",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Now in the initCell function we will specify each cells content and hit the List COMP Reset parameter to see the changes:"
+          },
+          {
+            "type": "code",
+            "text": "def onInitCell(comp, row, col, attribs):\n\t# grab the cell content from the Folder DAT\n\tcellContent = op('../folder1')[row,col].val\n\n\t# assign the text from the Folder DAT to the cell attribute\n\tattribs.text = cellContent\n\n\treturn",
+            "language": "python"
+          },
+          {
+            "type": "paragraph",
+            "text": "Right away we see the need to appropriately size the column width which we can do in the initCol function. Additionally we'll set the first column to be able to stretch, so that when we increase the List COMP width, the first column will adjust to that size while the rest of the columns stay the same. The initial width given to the stretchy column serves as it's minimal width. After editing hit the List COMP Reset parameter to see the changes."
+          },
+          {
+            "type": "code",
+            "text": "def onInitCol(comp, col, attribs):\n\t# specify each columns width in a list\n\tcolWidth = [150,150,250,90,90]\n\n\t# specify which column is stretchable in a list\n\tstretch = [1,0,0,0,0]\n\n\t# assign the width and stretch to the column attributes\n\tattribs.colWidth = colWidth[col]\n\tattribs.colStretch = stretch[col]\n\n\treturn",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "We can add further formatting to the List COMP in a general way via the initTable function and hit the List COMP Reset parameter to see the changes:"
+          },
+          {
+            "type": "code",
+            "text": "def onInitTable(comp, attribs):\n\t# set every cells justify to be center left\n\tattribs.textJustify = JustifyType.CENTERLEFT\n\n\t# set every cells bottom border to a slight blue\n\tattribs.bottomBorderOutColor = [0.2,0.2,0.6,1]\n\n\treturn",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "To change the look of a row when rolling over, edit the rollover callback function. The rollover callback function is called on and while your mouse is moving over a cell. Therefor when changing the layout of a row we should in this case compare the previous with the current rollover row and only change the bgColor when they are different. When rolling out of or into a List COMP the arguments for row, col, prevrow and prevcol will be -1 respectively."
+          },
+          {
+            "type": "code",
+            "text": "def onRollover(comp, row, col, coords, prevRow, prevCol, prevCoords):\n\t# make sure to only change the layout if row and prevRow are different\n\tif row != prevRow:\n\n\t\t# we don't want to change the header row so test for row being larger then 0\n\t\t# this also takes care of when rolling out of the List where row would return -1\n\t\tif row > 0:\n\t\t\trowAttribs = comp.rowAttribs[row]\n\t\t\trowAttribs.bgColor = [0.2,0.4,0.2,1]\n\n\t\t# same as before, we check that prevRow is not the header row and\n\t\t# we are not entering the List from the outside\n\t\tif prevRow > 0:\n\t\t\trowAttribs = comp.rowAttribs[prevRow]\n\t\t\trowAttribs.bgColor = [0.2,0.2,0.2,1]\n\n\treturn",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "To achieve a momentary click layout change on the List COMP we can use the select callback in a similar way as we used the rollover callback. The select callback additionally receives a start and end argument with start being True on mouse down and end being True on mouse up. As your mouse can move around the List COMP while the mouse is down, you also receive start and end row/col information. As we have no information on which row was previously selected, we will have to save the selected row in storage:"
+          },
+          {
+            "type": "code",
+            "text": "def onSelect(comp, startRow, startCol, startCoords, endRow, endCol, endCoords, start, end):\n\t# execute this on mouse down\n\tif start and startRow > 0:\n\t\t# get the row attributes for the clicked on row\n\t\t# and change the bgColor\n\t\trowAttribs = comp.rowAttribs[startRow]\n\t\trowAttribs.bgColor = [0.2,0.6,0.4,1]\n\n\t\t# save the startRow in storage so we can revert the layout changes on mouse up\n\t\tcomp.store('prevSelect',startRow)\n\n\t\t# run a script and pass row and column as an argument\n\t\top('../myScript').run(startRow, startCol)\n\t\n\t# execute this on mouse up\n\telif end:\n\t\t# get the previous selected row from storage\n\t\tprevSelRow = comp.fetch('prevSelect',None)\n\n\t\t# if there is a previously selected row change the layout back to default\n\t\tif prevSelRow:\n\t\t\trowAttribs = comp.rowAttribs[prevSelRow]\n\n\t\t\t# if my mouse is still over the previously selected row, change it's layout to the rollover bg\n\t\t\t# else change it to the default look\n\t\t\tif startRow == endRow:\n\t\t\t\tbgColor = [0.2,0.4,0.2,1]\n\t\t\telse:\n\t\t\t\tbgColor = [0.2,0.2,0.2,1]\n\n\t\t\t# assign the color to the rows bgColor attribute\n\t\t\trowAttribs.bgColor = bgColor\n\n\t\t# remove the previously selected row from storage\n\t\tcomp.unstore('prevSelect')\n\n\treturn",
+            "language": "python"
+          }
+        ]
+      },
+      {
+        "title": "Using a Python Dictionary as content for the List COMP",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "With the cell text content being assigned via the text attribute, we can also get data from structures like Lists or Dictionaries. For this example we will assume that our content dictionary has following structure:"
+          },
+          {
+            "type": "code",
+            "text": "myDict = {\n\t'header':[\n\t\t{'id':'name','label':'Name'},\n\t\t{'id':'extension','label':'Extension'},\n\t\t{'id':'type','label':'Type'},\n\t\t{'id':'size','label':'Size'}\n\t],\n\t'content':[\n\t\t{'name':'MyList.toe','extension':'toe','type':'TouchDesigner File','size':184666},\n\t\t{'name':'MyImage.jpg','extension':'jpg','type':'Image File','size':184326},\n\t\t{'name':'MyList1.toe','extension':'toe','type':'TouchDesigner File','size':184632},\n\t\t{'name':'MyList2.toe','extension':'toe','type':'TouchDesigner File','size':184536}\n\t]\n}",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The header key holds the information for the first row while the content key holds all other rows text. In order to gain access to the dictionary from the List COMP we will store this dictionary as an Dependency Class object to the List COMP."
+          },
+          {
+            "type": "code",
+            "text": "myListCOMP = op('/project1/myListCOMP')\nmyListCOMP.store('contentDict',tdu.Dependency(myDict))",
+            "language": "python"
+          },
+          {
+            "type": "paragraph",
+            "text": "To display as many Rows as there are items in the stored Dictionary, we'll change the List COMPs Row parameter to:"
+          },
+          {
+            "type": "code",
+            "text": "len(me.fetch('contentDict',{'content':[]}))+1",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Similarly for the Columns we will look at the size of the header dictionary:"
+          },
+          {
+            "type": "code",
+            "text": "len(me.fetch('contentDict',{'header':[]}))",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The second argument to the fetch Method is the default which will be returned in case the stored item is not found."
+          },
+          {
+            "type": "paragraph",
+            "text": "For the cells to display the correct content, we will need to fetch the stored dictionary in the initCell callback function and depending on row and column fetch the right entry from the content dictionary:"
+          },
+          {
+            "type": "code",
+            "text": "def onInitCell(comp, row, col, attribs):\n\tcontentDict = comp.fetch('contentDict',None)\n\tif contentDict:\n\t\theader = contentDict['header'][col]\n\t\tif row == 0:\n\t\t\tattribs.text = header['Label']\n\t\telse:\n\t\t\tid = header['id']\n\t\t\trowContent = contentDict[row-1]\n\t\t\tattribs.text = rowContent[id]\n\n\treturn",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "As we are using a Dependency Class object, with every update we make to the dictionary, the change will also be shown in the List COMP"
+          },
+          {
+            "type": "code",
+            "text": "myListCOMP = op('/project1/myListCOMP')\ncontentDict = myListCOMP.fetch('contentDict',None)\nnewItem = {'name':'someFile.toe','extension':'toe','type':'TouchDesigner File','size':932753}\ncontentDict['content'].append(newItem)",
+            "language": "python"
+          }
+        ]
+      }
+    ],
+    "tableOfContents": [
+      {
+        "number": "1",
+        "text": "Overview",
+        "href": "#Overview"
+      },
+      {
+        "number": "2",
+        "text": "Callbacks Stages",
+        "href": "#Callbacks_Stages"
+      },
+      {
+        "number": "3",
+        "text": "Building a simple List COMP with a Folder DAT as content source",
+        "href": "#Building_a_simple_List_COMP_with_a_Folder_DAT_as_content_source"
+      },
+      {
+        "number": "4",
+        "text": "Using a Python Dictionary as content for the List COMP",
+        "href": "#Using_a_Python_Dictionary_as_content_for_the_List_COMP"
+      }
+    ],
+    "relatedLinks": [
+      {
+        "text": "List COMP",
+        "href": "List_COMP.htm"
+      },
+      {
+        "text": "Folder DAT",
+        "href": "Folder_DAT.htm"
+      },
+      {
+        "text": "Text DAT",
+        "href": "Text_DAT.htm"
+      },
+      {
+        "text": "Dependency Class",
+        "href": "Dependency_Class.htm"
+      },
+      {
+        "text": "List COMPs",
+        "href": "List_COMP.htm"
+      }
+    ],
+    "images": []
+  },
+  "keywords": [
+    "build",
+    "list",
+    "comp",
+    "overview",
+    "callbacks",
+    "stages",
+    "building",
+    "simple",
+    "with",
+    "folder",
+    "content",
+    "source",
+    "using",
+    "python",
+    "dictionary",
+    "parameter",
+    "dat",
+    "mat"
+  ],
+  "tags": [
+    "Tutorial",
+    "TouchDesigner",
+    "Build a List COMP"
+  ],
+  "searchWeight": 2,
+  "lastUpdated": "2025-08-08T03:32:33.652Z",
+  "sourceFile": "C:\\Program Files\\Derivative\\TouchDesigner\\Samples\\Learn\\OfflineHelp\\https.docs.derivative.ca\\Build_a_List_COMP.htm",
+  "isValid": true,
+  "validationErrors": []
+}

package/dist/knowledge/data/tutorials/index.json

@@ -0,0 +1 @@
+[{"id":"anatomy_of_a_chop","name":"Anatomy of a CHOP","category":"TUTORIAL","summary":"Parameters of SOPs, TOPs and objects (components) are able to get values from CHOP channels with expressions like the following: However, exporting is preferred where possible. It is faster and involves less typing."},{"id":"build_a_list_comp","name":"Build a List COMP","category":"TUTORIAL","summary":"This document explains the finer points of building a List COMP. It is assumed the reader already has an understanding of the Python language. The official Python documentation can be found at this address. The List COMP runs its init callbacks when the Reset parameter is pulsed or on load. These init functions are in place to let the user assign Table, Row, Col or Cell specific attributes which determine the layout and look of the List. The four init functions are called in this order: Once initialized the following callback functions are run on specific events:"},{"id":"introduction_to_python_tutorial","name":"Introduction to Python Tutorial","category":"TUTORIAL","summary":"This tutorial is a general introduction to using Python in TouchDesigner. It doesn't require previous knowledge of Python, but it also doesn't go into \"how to program\". Resources for learning Python i..."},{"id":"tdbitwig_user_guide","name":"TDBitwig User Guide","category":"TUTORIAL","summary":"TDBitwig is a set of TouchDesigner components that enables bi-directional communication between Bitwig Studio and TouchDesigner. The TDBitwig functionality enables users to create custom audio-visual ..."},{"id":"touchdesigner_video_server_specification_guide","name":"TouchDesigner Video Server Specification Guide","category":"TUTORIAL","summary":"Windows 10 is the suggested windows operating system."},{"id":"video_streaming_user_guide","name":"Video Streaming User Guide","category":"TUTORIAL","summary":"This guide will cover the supported protocols and services that are now available to TouchDesigner users for audio video streaming over the Internet."},{"id":"write_a_cplusplus_chop","name":"Write a CPlusPlus CHOP","category":"TUTORIAL","summary":"Make sure you've read through Write a CPlusPlus Plugin first for general information about writing a plugin for a CPlusPlus CHOP. The CPlusPlus CHOP allows you to manipulate CHOP data using custom code, or bring in/output CHOP data to and from external sources or file formats. You can use one of the CHOP's inputs to determine the number of channels, channel names, sample rate etc. of the output, or you can specify them in code (in getOutputInfo())."},{"id":"write_a_cplusplus_plugin","name":"Write a C++ Plugin","category":"TUTORIAL","summary":"The CPlusPlus OPs (CPlusPlus CHOP, CPlusPlus TOP, CPlusPlus SOP and CPlusPlus DAT) allow you to load your own C++ code that has been compiled into a plugin. You can use this node to create custom filt..."},{"id":"write_a_cplusplus_top","name":"Write a CPlusPlus TOP","category":"TUTORIAL","summary":"Make sure you've read through Write a CPlusPlus Plugin first for general information about writing a plugin for a CPlusPlus TOP. The CPlusPlus TOP allows you to write C++ code to create a TOP that can output multiple textures. Currently you can create your output by filling a CPU memory buffer (TOP_ExecuteMode::CPUMem) or by filling a cudaArray buffer (TOP_ExecuteMode::CUDA). Most of the documentation is held in the header files for the C++ API. The samples also contain a lot of comments about the workflow."},{"id":"write_a_cuda_dll","name":"Write a CUDA DLL","category":"TUTORIAL","summary":"CUDA is a programming language developed by NVIDIA to allow developers to use the power of GPUs in a way much more general than using them only for graphics. More details about CUDA can be found at th..."},{"id":"write_a_glsl_material","name":"Write a GLSL Material","category":"TUTORIAL","summary":"This document explains the finer points of writing a GLSL Material in TouchDesigner. It is assumed the reader already has an understanding of the GLSL language. The official GLSL documentation can be ..."},{"id":"write_a_glsl_top","name":"Write a GLSL TOP","category":"TUTORIAL","summary":"The official GLSL documentation can be found at this address. TouchDesigner's main supported version of GLSL is 4.60. Support for versions of GLSL 3.30 and earlier have been removed due to the switch to Vulkan. A shader written for 3.30 should work fine when targeting newer GLSL though. A shader written for the GLSL TOP is generally a image based operation. It does essentially no geometry based work. For users who are familiar with writing 3D GLSL shaders, a GLSL TOP is simply a shader applied to a single quad that is drawn to cover up the entire viewport (also known as a full-screen-aligned quad). To simplify the subject, this guide will avoid the extra complexities involved in 3D rendering, and present the topic of writing a GLSL shader in a 2D world only, dealing only with pixels."},{"id":"write_a_shared_memory_chop","name":"Write a Shared Memory CHOP","category":"TUTORIAL","summary":"This article refers to how to write external applications to interface with Shared Mem Out CHOP and Shared Mem In CHOP. In the TouchDesigner installation directory, under /touch/SharedMem/CHOP there is the header defined in CHOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the channel data and optionally the channel data. NOTE: The 'Shared Mem Type' parameter in the CHOP must be set to 'Local' for your app to be able interface with it"},{"id":"write_a_shared_memory_top","name":"Write a Shared Memory TOP","category":"TUTORIAL","summary":"In the TouchDesigner installation directory, under Samples/SharedMem/TOP there is the header defined in TOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the image data. NOTE: The 'Shared Mem Type' parameter in the TOP must be set to 'Local' for your app to be able interface with it. Refer to the article Using Shared Memory in TouchDesigner to learn how to create a shared memory buffer. If you are the sender, you need to create a buffer whose size will accommodate both the header, and the image data. Get the size of the header simply with"}]