from a quick glance at the code you linked to, it appears they express the two vectors as follows:

a start point, and a unit vector in the desired direction, times a constant magnitude.

they then assume the two vectors intersect, and solve for the two constants when the resulting endpoints are the same:

unit_vector_1 * constant_1 = unit_vector_2 * constant_2

i'd find a book on vector math, use a different better documented algo, black box test thoroughly, or find a math nut who memorizes this kind of stuff.

So as the title suggest, do you copy code from the internet and put it in your game/engine without fully understanding it?

Sometimes. Less and less as time goes on. I do always go back, however, and work on that code later, to gain an eventual understanding.

But I bet swiftcoder understands what the code is doing and could write it from scratch if needed.

There is a big difference between using someone else's code (be it library or coworker) without having reviewed it, and using code that performs concepts that you don't understand. I don't want to write a Vector library or a PNG file loader if I don't have to. I am happy to use one. But I COULD write my own if I needed to. I think using using a library to perform tasks you do not understand will eventually come around and get you. It will be fine if nothing is wrong.

For example, a long time ago I needed to do a TFTP in Java. I grabbed a library from Apache. It ended up that there was a bug in the code that wouldn't ever allow the connection to work. I don't remember the specifics, but it was a nasty bug inside even nastier code ported from C. There were actually a bunch of gotos in the Java code.

I went out and found it: http://commons.apache.org/proper/commons-net/jacoco/org.apache.commons.net.tftp/TFTPClient.java.html#L129

Long story short (too late), if I didn't understand the underlying technology, not only would I have not known I was doing everything right, I wouldn't have been able to fix the bug.

There is nothing wrong with using someone else's code, but doing so without knowing you could write it yourself is a shortcut that will be paid for, one way or another.

But I bet swiftcoder understands what the code is doing and could write it from scratch if needed.

For the most part, yes. Some things (for example, quaternion conversions) continue to be a little black-box to me, though I've mostly farmed those out to 3rd party libraries (cml, in this instance).

However, I think your point applies almost as much to 3rd party libraries as it does to copy/pasted code. At least in the copy/paste case the components are usually small enough that one can understand them easily. If there is a bug in some upstream dependency like a physics engine, my ability to sit down and write a new physics engine is not quite so good :)

I use a set of Simplex noise functions I found online as a black box for procedural generation. It has a lot of math operations that may or may not be optimizable to my benefit, but I usually leave it alone. Although I did have to port it from Java to C#. There is also using Magic Bits for encoding and decoding Morton codes for interleaved values. It is harder to understand than the naive implementation, but it's also much quicker.

If there is a bug in some upstream dependency like a physics engine, my ability to sit down and write a new physics engine is not quite so good

Yes, but you see my point.

So as the title suggest, do you copy code from the internet and put it in your game/engine without fully understanding it?

To be fair, between copy pasting a block of code and including a lib into your project, there isn't that much of a difference.

There are quite a bit of things I wouldn't be able to do in my own (at least in a reasonable amount of time) such as: OpenGL wrapper, OpenGL itself, Bullet wrapper, Bullet itself, GLFW wrapper, GLFW itself, etc. And honestly, I don't have an issue with not knowing how to do those things.

There is this snippet of code in my shaders that basically is normal mapping without having to do the whole tangent/bitangent shenanigans. Its 12 lines of code, computes a few partial derivatives, a "cotangent frame", and voila, I got a normal mapped mesh!

I have no clue how it works, but it does. It saves me up the trouble of doing my own tangent/bitangent computation code when loading models (I hate coding file loaders, its the most unrewarding thing ever for me). I sort of get the idea of normal mapping, of using "tangent space" to make the normal map valid no matter the transformations the mesh is subjected to, but thats all I know, I have no idea how it works.

That's a success story, there is also a failure one:

For my deferred renderer, I based the position reconstruction code from a blog post. I didn't knew exactly how it worked but I rolled with it. Position reconstruction was used for computing lighting, and turns out it didn't worked at all. I spent weeks on and off from that code until I narrowed it down to the last step in the position reconstruction process. Showing the view space positions I could see XY plane was working fine, but Z was broken, it was either too far or behind the camera. Looking at the code I noticed that the NDC to view space depth function was... iffy, it didn't seemed right.

Checked resources around on NDC space and how OpenGL stores depth values in the depth buffer, and remade the function in a way I thought it would be correct. With the proper view space depth function working, lighting equations could work properly.

I'm not a very big fan of math so those are the spots where I end up searching for code. I enjoy a lot the "architecture" part though, so I do have my own math classes because I simply dislike the structure of the math libraries I found out there for Java.

There are parts that one likes to do, and parts that one doesn't likes to do. I'd say that if anyone expects to make anything, game or whatever, they should recognise the parts they don't like and fill it with libs as soon as possible. Don't sweat over it, just concentrate on what you like.

In general I think most people have used code that isn't theirs. I think a much more pertinent question is if everyone provides proper credit for the snippet. There are a few places in Hieroglyph 3 where I link to the StackOverflow topic where some code came from. In particular, code for converting from std::string to std::wstring is totally ridiculous and complex, but I found a snippet that worked well so I linked to the topic in a comment. I understand it at a high level, but I couldn't rewrite it from scratch without a reference...