SWest
...(Houdini 19.5 [www.sidefx.com]) ...

tamte
it's here:

SWest
...(Houdini 19.5 [www.sidefx.com]) ...

just follow any of the subtopics to learn more about the syntax

tamte
you can also refer to Matt's CGWiki for some quide and examples
https://www.tokeru.com/cgwiki/JoyOfVex [www.tokeru.com]
https://www.tokeru.com/cgwiki/HoudiniVex [www.tokeru.com]

SWest
With Python I can focus on logic (algorithms) because there are so many examples that can be used to solve the syntax questions. However, this approach is not possible with VEX using the given tools available.

SWest
And my experience is that it is much like a labyrinth.

SWest
With Python I can focus on logic (algorithms) because there are so many examples that can be used to solve the syntax questions. However, this approach is not possible with VEX using the given tools available.

SWest
Having many short examples, especially from function or object oriented programming (or both) could make using VEX more accessible.

BabaJ
Short examples of what? What do you feel is missing?

// a function that deletes a cregion
function string delCreg(string creg_names[]; string creg_to_del; int boneCapture_i[]; float boneCapture_d[])
{
// arguments are references to the actual attributes


// here (in the function) this will still work because the real array is referenced
// here a cregion is deleted
pop( boneCapture_i, index_to_del );
pop( boneCapture_d, index_to_del );

[...]

// calling the function (working example)
delCreg(creg_names, creg_to_del, @boneCapture_index, @boneCapture_data);



// note: placing @boneCapture_index as an argument for the above function does not seem to work. 
function string delCreg(string creg_names[]; string creg_to_del; int @boneCapture_index[]; float boneCapture_d[])
function string delCreg(string creg_names[]; string creg_to_del; @boneCapture_index; float boneCapture_d[])



// this is the example from the docs
function int test(int a, b; string c) {

SWest
// note: placing @boneCapture_index as an argument for the above function does not seem to work.
function string delCreg(string creg_names; string creg_to_del; int @boneCapture_index; float boneCapture_d)
function string delCreg(string creg_names; string creg_to_del; @boneCapture_index; float boneCapture_d)

SWest
// this is the example from the docs
function int test(int a, b; string c) {

SWest
Another example could be, imagine you want your function to return an array, how would to do that? Coming from a Python background this was quite challenging.

LuSkar
jerry7
You can disable MoveToGoodPosition():


import hou
def foo(obj,relative_to_inputs=True, move_inputs=True, move_outputs=True, move_unconnected=True):
return

hou.session.__bak_moveToGoodPosition = hou.Node.moveToGoodPosition
hou.Node.moveToGoodPosition = foo


If you want to restore:

import hou
hou.Node.moveToGoodPosition = hou.session.__bak_moveToGoodPosition

for someone already familiar with Python

SWest
The example you gave I see as a solution to a problem. The fuction can’t be empty.

• Learning programming is relativaly challenging because it implies several skills. For example first of all understanding how something works in the first place. Then it requires more or less project management abilities about how to go about doing something. Then this has to be explained to the (rather stupid) computer.
  
• This also include a lot of problem solving on the way to implementing features. Finally there is the need for documentation, user friendlieness, maybe refactoring and probably some maintainance. Learning syntax is just the tip of the ice berg. However, once these abilities are developed they can be translated to other contexts and languages.
  
• AI is NOT the genious of machines, but ONLY the excellence of human collaboration and design when using machines.
  
• Python is a quite slow programming language, but works way faster than humans do. So it is popular to use as an interface API. Data scientists often use Python, maybe partially because their salaries are higher than the cost for simply adding more CPU:s.
  
• Python is fast to program (for those who know it well) and useful for prototyping.
  
• Python is like the glue between the human being and the low level code (C/C++ or equivalent).
  
• If something is too slow then it is possible to use Python to call a C/C++ program that optimizes only that part.
  
• Python also support multiprocessing, but so does C/C++.
  
• Computer Science has two main branches: Information Systems and Computing. "Information Systems" are not focused on low level performance but rather human interaction. The "Computing" branch however is more oriented towards high performance and low-level thinking. There is no conflict about that, just different tools for different purposes.
  

• Probably the most important statement i.e. the plan for the following code. It represents the thinking human behind everything.
  
• The alorithm implied is to create a function that does nothing, but does neither produce an error.
  
• It also implies a backup of the original functionality.
  
• Comments do not explain the underlying code to humans, but the opposite, the code beneath the comment explains the comment to the computer.
  

• import the entire HOM with classes as well as the present objects in the scene definition.
  
• Classes will begin with capital letter i.e. "Foo()". Objects generated from them inherit the same name but begin with a lowercase letter i.e. "foo()".
  
• Each object generated has methods (like built-in functions).
  
• Parms usually use lowercase with underscore this_is_a_parm.
  
• The above mentioned approach is consistently used in the HOM (import hou).
  
• Classes and objects usually have built in descriptions, i.e. the '''description''' line(s) directly under the first line. This is the pop-up available in the embedded Python Shell and is standard for Python.
  

import hou

• Define this method called foo (here it looks identical to a function).
  
• Obj is a positional argument that is required, while all other arguments are predefined and have a default data type and value (the value may be overridden but not the type).
  
• The arguments are not really needed for this seemingly empty function, but to avoid error messages when the args are sent from various places in the HOM they are used here.
  

def foo(obj,relative_to_inputs=True, move_inputs=True, move_outputs=True, move_unconnected=True):

• The following returns nothing, maybe it is a Null or something equivalent.
  
• Here it become similar to just a "break" in a loop but that will not work in a function. However simply using a return will satisfy the Python rules for methods (and functions).
  

return

• Here hou.session is used, which is defined and stored until you restart Houdini.
  
• It is useful when you want to be able to "retrieve" your own Python modules, classes, variables or whatever inside Houdini. So here it is used to store a backup of the original function moveToGoodPosition() in the Class called "Node" (note the beginning letter).
  
• The name __bak_moveToGoodPosition is arbitrary.
  

hou.session.__bak_moveToGoodPosition = hou.Node.moveToGoodPosition

• Here the method "moveToGoodPosition" inside the Class "Node" is overridden by the function "foo". What this mean is that for each new object node (lowercase letters) that is generated from the "Node" class the method does nothing.
  

hou.Node.moveToGoodPosition = foo

• As mentioned, some user support is required by the programming role.
  
• On one hand you can not assume that the CPU or language will understand what you are doing (it is stupid in that sence). It helps to imagine that you are defining things in empty space (vacuum) and nothing exist unless you define it.
  
• On the other hand it is risky to assume that the intended user understands what you have done.
  
• In that perspective the programming role resembles that of the translators, i.e. to translate a plan to the computer, then somehow translate that to the user. Well, this is only part of the story.
  

import hou

• Here the backup of the function/method moveToGoodPosition in the Class "Node" is stored in the session and can be copied back as in the following line.
  
• We usually use versions to prevent the risks of human errors but also for communication within teams and with the target group. The idea of safety measures is very important to avoid loosing motivation (time, value and money) due to lost work.
  

hou.Node.moveToGoodPosition = hou.session.__bak_moveToGoodPosition