Connecting together two tubes using indices and trianglestrips [500 points]

Thanks for the help ike, I've attached 4 pictures, each are labelled in the order they should be opened.

I've tried to show that the two tubes will draw separately with no problems.  When they are joined there are no problems until one or both of the tubes are rotated.

I all cases cull mode has been turned off.

Ok, that shows it very well, thank you.

>> I've tried to show that the two tubes will draw separately with no problems.  
>> When they are joined there are no problems until one or both of the tubes are rotated.

The problem is there before, its just *hidden* because the wrong lines lie where correct lines are anyway.

>> two tubes will draw separately with no problems

Do you have different render-strategies, when you render the 3 tubes compared to the 2 tubes?
I guess the 3 tubes are rendered by just one triangle-strip. In contrast, the 2 tubes with 2 triangle-strips, each tube has its own, right?
Render each tube seperately with its own triangle strip, That should do it, it does it for 2 tubes, so it will be fine for 3 tubes too.

I thought about doing the exact same thing but it left me with two problems:

- How do I find the correct central position of the connecting tube?
- How can I batch draw all the tubes in one call rather than drawing each one separately?

The connecting tube vertices could easily be found with the code below:

            debug_Tube[0] = new Tube(4, new Vector3(-2, 0, 0), Quaternion.CreateFromYawPitchRoll(0, 0, 1), 1);
            debug_Tube[1] = new Tube(4, new Vector3(-2, 5, 0), Quaternion.Identity, 1);
 
            // Created from debug_Tube[0] vertices AND debug_Tube[1] vertices
            debug_Tube[2] = new Tube(4, position???, Quaternion.Identity, 1);
            debug_Tube[2].Vertices[0] = debug_Tube[0].Vertices_Transformed[1];
            debug_Tube[2].Vertices[1] = debug_Tube[1].Vertices_Transformed[0];
            debug_Tube[2].Vertices[2] = debug_Tube[0].Vertices_Transformed[3];
            debug_Tube[2].Vertices[3] = debug_Tube[1].Vertices_Transformed[2];
            debug_Tube[2].Vertices[4] = debug_Tube[0].Vertices_Transformed[5];
            debug_Tube[2].Vertices[5] = debug_Tube[1].Vertices_Transformed[4];
            debug_Tube[2].Vertices[6] = debug_Tube[0].Vertices_Transformed[7];
            debug_Tube[2].Vertices[7] = debug_Tube[1].Vertices_Transformed[6];
            debug_Tube[2].Vertices[8] = debug_Tube[0].Vertices_Transformed[9];
            debug_Tube[2].Vertices[9] = debug_Tube[1].Vertices_Transformed[8];

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

The point is, the vertices are in object local coordinates for debug_Tube[0] and debug_Tube[1], they are relative to their origin/center, Vector3(-2, 0, 0) for debug_Tube[0] and Vector3(-2, 5, 0) for debug_Tube[1]

I would do this (I'm a C++ guy, so not real C#, but I think you get what I mean)

1) Calculate the World-coordinates for tube 2 from object-local-coordinates of tube 0 and 1 by adding their centerpoint

Vector3 tubePointsWorld[10];

tubePointsWorld[0] = debug_Tube[0].Vertices_Transformed[1] + Vector3(-2, 0, 0);
tubePointsWorld[1] = debug_Tube[1].Vertices_Transformed[0] + Vector3(-2, 5, 0);
tubePointsWorld[2] = debug_Tube[0].Vertices_Transformed[3] + Vector3(-2, 0, 0);
tubePointsWorld[3] = debug_Tube[1].Vertices_Transformed[2] + Vector3(-2, 5, 0);
tubePointsWorld[4] = debug_Tube[0].Vertices_Transformed[5] + Vector3(-2, 0, 0);
tubePointsWorld[5] = debug_Tube[1].Vertices_Transformed[4] + Vector3(-2, 5, 0);
tubePointsWorld[6] = debug_Tube[0].Vertices_Transformed[7] + Vector3(-2, 0, 0);
tubePointsWorld[7] = debug_Tube[1].Vertices_Transformed[6] + Vector3(-2, 5, 0);
tubePointsWorld[8] = debug_Tube[0].Vertices_Transformed[9] + Vector3(-2, 0, 0);
tubePointsWorld[9] = debug_Tube[1].Vertices_Transformed[8] + Vector3(-2, 5, 0);

2) Calculate the midpoint (center-pos) by adding all tubePointsWorld's and divide it by 10

Vector3 pos(0.0, 0.0, 0.0);
for(int i = 0; i < 10; ++i)
{
    pos += tubePointsWorld[i];
}
pos /= 10;

3) Calculate the local tube-points relative to its center

for(int i = 0; i < 10; ++i)
{
    tubePointsWorld[i] -= pos;
}


Thats it, now you have the coordinates of the tube in object-space in "tubePointsWorld" and the position of the tube in "pos"

Just realize "tubePointsWorld" is not a good name anymore in point 3)
Its not world anymore, its object-local, but you get what I mean :)

>>1) Calculate the World-coordinates for tube 2 from object-local-coordinates of tube 0 and 1 by adding >>their centerpoint

vertices_Transformed = World Coordinates (not object-local-coordinates)
vertices = Local Coordinates

Following exactly what you have said does not work?

            // Created from debug_Tube[0] vertices AND debug_Tube[1] vertices
            debug_Tube[2] = new Tube(4, Vector3.Zero, Quaternion.Identity, 1);
 
            debug_Tube[2].Vertices_Transformed[0] = debug_Tube[0].Vertices[1];
            debug_Tube[2].Vertices_Transformed[0].Position += debug_Tube[0].Position;
 
            debug_Tube[2].Vertices_Transformed[1] = debug_Tube[1].Vertices[0];
            debug_Tube[2].Vertices_Transformed[1].Position += debug_Tube[1].Position;
 
            debug_Tube[2].Vertices_Transformed[2] = debug_Tube[0].Vertices[3];
            debug_Tube[2].Vertices_Transformed[2].Position += debug_Tube[0].Position;
 
            debug_Tube[2].Vertices_Transformed[3] = debug_Tube[1].Vertices[2];
            debug_Tube[2].Vertices_Transformed[3].Position += debug_Tube[1].Position;
 
            debug_Tube[2].Vertices_Transformed[4] = debug_Tube[0].Vertices[5];
            debug_Tube[2].Vertices_Transformed[4].Position += debug_Tube[0].Position;
 
            debug_Tube[2].Vertices_Transformed[5] = debug_Tube[1].Vertices[4];
            debug_Tube[2].Vertices_Transformed[5].Position += debug_Tube[1].Position;
 
            debug_Tube[2].Vertices_Transformed[6] = debug_Tube[0].Vertices[7];
            debug_Tube[2].Vertices_Transformed[6].Position += debug_Tube[0].Position;
 
            debug_Tube[2].Vertices_Transformed[7] = debug_Tube[1].Vertices[6];
            debug_Tube[2].Vertices_Transformed[7].Position += debug_Tube[1].Position;
 
            debug_Tube[2].Vertices_Transformed[8] = debug_Tube[0].Vertices[9];
            debug_Tube[2].Vertices_Transformed[8].Position += debug_Tube[0].Position;
 
            debug_Tube[2].Vertices_Transformed[9] = debug_Tube[1].Vertices[8];
            debug_Tube[2].Vertices_Transformed[9].Position += debug_Tube[1].Position;
 
            for (int i = 0; i < 10; i++)
            {
                debug_Tube[2].Position += debug_Tube[2].Vertices[i].Position;
            }
 
            debug_Tube[2].Position /= 10.0f;
 
            for (int i = 0; i < 10; ++i)
            {
                debug_Tube[2].Vertices[i].Position -= debug_Tube[2].Position;
            }

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

This method works perfectly but then the vertices are not local space any more:

            for (int i = 0; i < debug_Tube[0].Vertices.Length; i++)
            {
                debug_Tube[2].Vertices[i] = debug_Tube[0].Vertices_Transformed[i + 1];
                debug_Tube[2].Vertices[++i] = debug_Tube[1].Vertices_Transformed[i - 1];
            }

                                              

1:
2:
3:
4:
5:

The logic is ok, must be the implementation. Check the values of the calculation, print them out or use the debugger. If you are stuck post the values here, we take it from there

Thanks ike.

I am still left with the major issue that I can't draw all the tubes in one call.  If they are all drawn as a triangle strip then this seems unfeasible to me as it will create the original error shown in the pictures.  

As you have more knowledge than I do can you possible suggest a way forward?

Not for a single list of triangle strips. That just dont work, because they have to be connected in a certain way, but they are not.
You can use a normal triangle list, if you need _one_ list.
But whats wrong with multiple lists? Its normal to use different lists for different objects.