I've been working with object rotations within a C++ Addin, and I have most of the desired features working. However, one of the goals is to find a rotation center based on the center of the view/screen intersection with the model. I have this working for part documents (using rays, bounding box intersection checks, and IRayIntersection for vertex locating). however, assembly documents have given me much frustration.

I'm down to one issue which is holding me up... I'm trying to convert bounding boxes of certain features from object space to world space... So, I grab the components Transform2 (via get_Transform2) matrix. I then multiply this by the bounding box extents - I do this for each face. Now, this almost works, but the result is not at all accurate. The resulting boxes end up skewed, completely out of place, etc depending on the inserted parts orientation.

For testing my own code, I created a simple rotation transform which I rotated all the boxes by, and got good results (of course not rotated to the correct world space coordinates of where the component really is). Though, there may still be a bug lurking in my code. but, it seems to me the rotation matrix coming from Transform2 is wrong or I do not know what it really represents.

Relevant code & screen shot attached - points of box should line up with object, but instead appear slanted (if I do not apply Transform2 or if I apply my own transform, box is intact):

    IComponent2 **children = new IComponent2*[childrenCount];
    memset(children, 0, sizeof(IComponent2*) * childrenCount);
    comp->IGetChildren(children);

    //Helpers
    HRESULT res;
    VARIANT_BOOL ret;
    CComPtr bp1, bp2;
    double p[3] = {0,0,0};
    iMathUtility->ICreatePoint(p, &bp1);
    iMathUtility->ICreatePoint(p, &bp2);

    for(int childComponents = 0; childComponents < childrenCount; ++childComponents)
    {
        if(!children[childComponents])
            continue;

        CComPtr cComp;
        cComp.Attach(children[childComponents]);

        CComPtr transform;

        IFeature *next = 0;
        if(FAILED(cComp->FirstFeature(&next)))
            continue;

        cComp->get_Transform2(&transform);

        while(next)
        {
            BodyItem bItem;

            //Only track features that mean something to us
            BSTR type = 0, value = 0;
            res = next->GetNameForSelection(&type, &value);
            if(type && value && (wcscmp(type, L"BODYFEATURE") == 0 || wcscmp(type, L"") == 0))
            {
                long faceCount = 0;
                next->GetFaceCount(&faceCount);
                if(faceCount > mFaceListSize)
                {    //Resize as needed
                    delete [] mFaceList;
                    mFaceListSize = faceCount;
                    mFaceList = new IFace2*[mFaceListSize];
                }

                if(faceCount > 0)
                {
                    next->IGetFaces2(&faceCount, mFaceList);
                    for(int childFace = 0; childFace < faceCount; ++childFace)
                    {
                        mFaceList[childFace]->IGetBox(bItem.box.box);
                        bItem.box.initialized = true;

                        IBody2 *body = 0;
                        mFaceList[childFace]->IGetBody(&body);

                        if(body)
                        {
                            //Now transform the box to the new coords
                            bp1->put_IArrayData(&(bItem.box.box[0]));
                            CComPtr nbp1;
                            bp1->IMultiplyTransform(transform, &nbp1);
                            nbp1->get_IArrayData(&(bItem.box.box[0]));

                            bp2->put_IArrayData(&(bItem.box.box[3]));
                            CComPtr nbp2;
                            bp2->IMultiplyTransform(transform, &nbp2);
                            nbp2->get_IArrayData(&(bItem.box.box[3]));

                            DebugDrawBox(bItem.box);

                            bItem.body = body;
                            bItem.face = mFaceList[childFace];
                            mBodies.push_back(bItem);
                        }
                    }
                }
            }

            IFeature *feature = 0;
            res = next->IGetNextFeature(&feature);
            if(res != S_OK || !feature)
                feature = 0;

            next->Release();
            next = feature;
        }
    }

Note: bItem is simply a class holding a body, face, and boundingbox class item. The box.box is simply an array of 6 doubles (xyz, xyz). Any help is welcome.