Your intuition of setting the two equations equal is correct and that is how you solve for the intersection. I'll provide a full explanation, with code examples.
A common way of representing a plane $\mathbf{P}$ is in point-normal form, $\mathbf{\vec{n}} \cdot (X-Y)=0$, where $\mathbf{\vec{n}}$ is the plane normal and both $X$ and $Y$ are points that lie in the plane. This can be rewritten into constant-normal form by distributing the dot product and rearranging terms to obtain: $\mathbf{\vec{n}} \cdot X = d$, where $d = \mathbf{\vec{n}} \cdot Y$ which is equal to the distance from the origin when $\mathbf{\vec{n}}$ is unit-length. Below is a simple data structure that you might use to represent a plane, and the signature of a constructor that will compute the plane from three points in $\mathbb{R^3}$. Implementation is left as an exercise to the reader ;).
struct Plane {
Vector3 n; // normal
float d; // distance from origin
Plane(); // default constructor
Plane(Vector3 a, Vector3 b, Vector3 c); // plane from 3 points
Vector3 intersectLine(Vector3 a, Vector3 b); // we'll get to this later
};
Given two points, $A$ and $B$, a line can be represented parametrically by adding to one point the vector formed by the two points, scaled by a parameter $t$. In symbols, $L(t) = A + t(B-A)$. Using your intuition, we insert this equation (whose output is a point), into $X$ in the constant-normal plane representation: $\mathbf{\vec{n}} \cdot [A + t(B-A)] = d$. We want to know how many copies of $(B-A)$ we need to add to $A$ to get to a point that lies within the plane, in other words we want to solve for $t$. Doing some fancy algebra, we obtain: $t = \frac{d-\mathbf{\vec{n}} \cdot A}{\mathbf{\vec{n}} \cdot (B-A)}$. We can (finally) stick this expression for $t$ back into the equation for our line to obtain: $I = A+\frac{d - (\mathbf{\vec{n}} \cdot A)}{\mathbf{\vec{n}} \cdot (B-A)}(B-A).$
Armed with this equation, we can now implement a nice function that will tell what we want to know:
Vector3 Plane::intersectLine(Vector3 a, Vector3 b) {
Vector3 ba = b-a;
float nDotA = Vector3::dotProduct(n, a);
float nDotBA = Vector3::dotProduct(n, ba);
return a + (((d - nDotA)/nDotBA) * ba);
}
Hopefully this works for you, and hopefully I didn't fudge any of the details! If you plan to be doing a lot of this sort of geometric computing it's worthwhile to pick up Christer Ericson's Real-time Collision Detection, which is an excellent reference source for this sort of thing. Alternatively, you could snag some already-constructed classes from something like OGRE3D, if you're not particularly interested in creating your own.
The normal vector to the plane is $n=(3,2,5)$, from that we can find the angles we are interested in using dot product.
For example the angle for the normal with $x-y$ plane, with normal $e_3=(0,0,1)$ is given by
$$\cos \theta=\frac{n\cdot e_3}{|n||e_3|}=\frac{5}{\sqrt{28}}$$
Best Answer
This is a fairly standard problem in CAD. One place to start would be this section from the on-line book by Patrikalakis-Maekawa-Cho. In addition, you can search their bibliography page for the word "intersection" or you could search this much larger bibliography.
The more general problem is intersecting two surfaces. Intersecting a surface and a plane is simpler, but still not easy.
There are several possible approaches. One of them is actually quite similar to the technique you mentioned -- dividing the surface into triangles, and intersecting these with the plane to form line segments. The data size problems you mentioned are avoidable. You only need to generate tiny triangles near the plane (not everywhere), and you can disgard a triangle after you've used it. The more common approach is to "march" along the intersection curve, as described in the reference. In either case, the result will be some sort of spline curve that approximates the intersection.
It's not too difficult to write an algorithm that works 80% of the time. But, occasionally, there will be cases where the plane is tangent (or nearly tangent) to the surface. Dealing with these cases reliably is pretty difficult.
If you don't know some mathematics (multivariate calculus, at least) it's going to be tough for you to read most of the literature on the subject.