Beispiel #1
0
bool FolderView::Create(CWnd* parent, UINT id, FolderPathPtr path/*= 0*/, bool root/*= true*/)
{
	root_ = path;

	if (!CTreeCtrl::Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP |
		TVS_DISABLEDRAGDROP | TVS_HASBUTTONS | TVS_HASLINES | TVS_SHOWSELALWAYS,
		CRect(0,0,0,0), parent, id))
		return false;

#ifndef TVS_EX_DOUBLEBUFFER
#define TVS_EX_DOUBLEBUFFER 0x0004
#endif

	TreeView_SetExtendedStyle(m_hWnd, TVS_EX_DOUBLEBUFFER, TVS_EX_DOUBLEBUFFER);

	SendMessage(WM_SETFONT, WPARAM(::GetStockObject(DEFAULT_GUI_FONT)));

	if (!SetImageList())
	{
		ASSERT(false);
	//	return false;
	}

	folder_as_root_ = root;

	if (root_)
		if (HTREEITEM item= SetupRoot(root_, folder_as_root_))
		{
			tree_->Expand(item, TVE_EXPAND);
			tree_->SelectItem(item);
		}

	return true;
}
Beispiel #2
0
void FolderView::Refresh()
{
	HTREEITEM item;

	if (!(item = tree_->GetRootItem()))
	{
		SetupRoot(root_, folder_as_root_);
		return;
	}

	UpdateItem(item);
}
Beispiel #3
0
void FolderView::Reset(FolderPathPtr path, bool root/*= true*/)
{
	DeleteAllItems();
	list_.DeleteAll();

	folder_as_root_ = root;
	//idl_root_.Free();
	//if (root_idl)
		root_ = path;

	if (HTREEITEM item= SetupRoot(root_, folder_as_root_))
	{
		tree_->Expand(item, TVE_EXPAND);
		tree_->SelectItem(item);
	}
}
Beispiel #4
0
void TerrainCellRData::ConnectCell (TerrainCellRData* otherCell, TerrainCellBorderMatch side)
{
  size_t sideIdx = (size_t)side;
  size_t sideBackIdx = 3-sideIdx;

  // Reduce other cell to be small enough for making connection
  if (rootBlock)
    rootBlock->Merge ();

  if (otherCell->rootBlock)
    otherCell->rootBlock->Merge ();

  neighbours[sideIdx] = otherCell;
  otherCell->neighbours[sideBackIdx] = this;

  // Make sure both actually have a root
  SetupRoot ();
  otherCell->SetupRoot ();

  rootBlock->neighbours[sideIdx] = otherCell->rootBlock;
  otherCell->rootBlock->neighbours[sideBackIdx] = rootBlock;
}
Beispiel #5
0
Bool Mesh::Manager::InitResources()
{
    // setup the NULL root
    //
    nullRoot = new MeshRoot();
    ASSERT( nullRoot);

    FamilyState meshState;
    meshState.ClearData();
    nullRoot->SetupStates( &meshState, 1);

    nullRoot->SetName( "null");
    SetupRoot( *nullRoot, "null");

    // other stuff
    //
    Vid::renderState.mrmAutoFactor = 1.0f;

    curChild = selChild = NULL;
    curEnt   = selEnt   = NULL;
    curParent = NULL;

    return TRUE;
}
Beispiel #6
0
MeshRoot * Mesh::Manager::MakeGlobe( F32 radius, U32 bands, Bitmap * texture)
{
    U32 i, j, LastIndex, BandsX2, LastBandStartIndex;
    U32 TopBandStartIndex, BottomBandStartIndex, zvert;
    U32 dowrap = 1;
//	U32 dowrap = 0;
    Vector BaseVec, BandVec, WVec, TempVec;
    F32 zmin, c1, c2, c0, stickwid, r1, r2;
    F32 *rads;

    BandsX2 = bands*2;

    Quaternion att;
    Matrix matY, matZ;
    matY.ClearData();
    matZ.ClearData();

    att.Set( PI / bands, Matrix::I.Up());
    matY.Set( att);

    att.Set( PI / bands, Matrix::I.Front());
    matZ.Set( att);

    U32 vertC = 2 + (BandsX2 + 1) * (bands - 1);
    U32 faceC = BandsX2 * bands + BandsX2 * (bands - 2);

    rads = new F32[bands + 1];
    ASSERT( rads);

    MeshRoot * root = MakeMesh( vertC, vertC, vertC, faceC, texture);
    Vector  * vects = root->vertices.data;
    Vector  * norms = root->normals.data;
    UVPair  * uvs   = root->uvs.data;
    FaceObj * faces = root->faces.data;

    zmin = 32000.0f;
    // point at the top
    BaseVec.x = 0.0f;
    BaseVec.y = radius;
    BaseVec.z = 0.0f;

    U32 vertCount = 0, faceCount = 0;
    vects[vertCount] = BaseVec;
    norms[vertCount] = norms[vertCount];
    norms[vertCount].Normalize();
    vertCount++;

    BandVec = BaseVec;

    // create the vertices in each band in turn
    for (i = 1; i < bands; i++)
    {
        // rotate around Z to the next band's latitude
        matZ.Transform( TempVec, BandVec);

        WVec = BandVec = TempVec;
        rads[i] = (F32) sqrt( WVec.x * WVec.x + WVec.z * WVec.z);
        // do the vertices in this band
        U32 startVert = vertCount;
        for (j = 0; j < BandsX2; j++)
        {
            WVec = TempVec;
            vects[vertCount] = WVec;
            norms[vertCount] = vects[vertCount];
            norms[vertCount].Normalize();
            vertCount++;

            if (WVec.z < zmin)
            {
                zmin = WVec.z;
                zvert = vertCount;
            }
            // rotate around Y to the next vertex's longitude
            matY.Transform( TempVec, WVec);
        }
        // duplicate band start vert at the end (for texture wrapping)
        vects[vertCount] = vects[startVert];
        norms[vertCount] = vects[vertCount];
        norms[vertCount].Normalize();
        vertCount++;
    }
    // point at the bottom
    BaseVec.y = -radius;
    vects[vertCount] = BaseVec;
    norms[vertCount] = vects[vertCount];
    norms[vertCount].Normalize();
    LastIndex = vertCount;
    vertCount++;

    r1 = 0.0f;
    r2 = 1.0f / (F32) bands;
    // top band
    stickwid = 100 * rads[1] / radius;
    stickwid += (100 - stickwid)/2;
    for (i = 0; i < BandsX2; i++, faceCount++)
    {
        faces[faceCount].verts[0] = 0;
//		faces[faceCount].verts[1] = ((i + 1) % BandsX2) + 1;
        faces[faceCount].verts[1] = (WORD) (((i + 1) % (BandsX2 + 1)) + 1);
        faces[faceCount].verts[2] = (WORD) (i + 1);

        faces[faceCount].norms[0] = faces[faceCount].verts[0];
        faces[faceCount].norms[1] = faces[faceCount].verts[1];
        faces[faceCount].norms[2] = faces[faceCount].verts[2];

        faces[faceCount].uvs[0] = faces[faceCount].verts[0];
        faces[faceCount].uvs[1] = faces[faceCount].verts[1];
        faces[faceCount].uvs[2] = faces[faceCount].verts[2];
        faces[faceCount].buckyIndex = 0;

        if (dowrap == 1)
        {
            c1 = (F32) i / (F32) BandsX2;
            c2 = (F32) (i + 1) / (F32) BandsX2;
            c0 = (c1 + 0.5f) / (F32) BandsX2;

            uvs[faces[faceCount].verts[0]].u = c0;
            uvs[faces[faceCount].verts[0]].v = r1;

            uvs[faces[faceCount].verts[1]].u = c1;
            uvs[faces[faceCount].verts[1]].v = r2;

            uvs[faces[faceCount].verts[2]].u = c2;
            uvs[faces[faceCount].verts[2]].v = r2;
        }
        else
        {
            uvs[faces[faceCount].verts[0]].u = 0.5f;
            uvs[faces[faceCount].verts[0]].v = 0.0f;

            uvs[faces[faceCount].verts[1]].u = 0.0f;
            uvs[faces[faceCount].verts[1]].v = 1.0f;

            uvs[faces[faceCount].verts[2]].u = 1.0f;
            uvs[faces[faceCount].verts[2]].v = 1.0f;
        }
    }

    // middle bands
    for (j = 0; j < bands - 2; j++)
    {
//		TopBandStartIndex = j * BandsX2 + 1;
//		BottomBandStartIndex = (j + 1) * BandsX2 + 1;
        TopBandStartIndex = j * (BandsX2 + 1) + 1;
        BottomBandStartIndex = (j + 1) * (BandsX2 + 1) + 1;
        r1 = (F32) (j + 1) / (F32) bands;
        r2 = (F32) (j + 2) / (F32) bands;
        for (i = 0; i < BandsX2; i++, faceCount += 2)
        {
            faces[faceCount].verts[0] = (WORD) (i + TopBandStartIndex);
//			faces[faceCount].verts[1] = ((i + 1) % BandsX2) + TopBandStartIndex;
//			faces[faceCount].verts[2] = ((i + 1) % BandsX2) + BottomBandStartIndex;
            faces[faceCount].verts[1] = (WORD) (((i + 1) % (BandsX2 + 1)) + TopBandStartIndex);
            faces[faceCount].verts[2] = (WORD) (((i + 1) % (BandsX2 + 1)) + BottomBandStartIndex);

            faces[faceCount].norms[0] = faces[faceCount].verts[0];
            faces[faceCount].norms[1] = faces[faceCount].verts[1];
            faces[faceCount].norms[2] = faces[faceCount].verts[2];

            faces[faceCount].uvs[0] = faces[faceCount].verts[0];
            faces[faceCount].uvs[1] = faces[faceCount].verts[1];
            faces[faceCount].uvs[2] = faces[faceCount].verts[2];
            faces[faceCount].buckyIndex = 0;

//			faces[faceCount+1].verts[0] = ((i + 1) % BandsX2) + BottomBandStartIndex;
            faces[faceCount+1].verts[0] = (WORD) (((i + 1) % (BandsX2 + 1)) + BottomBandStartIndex);
            faces[faceCount+1].verts[1] = (WORD) (i + BottomBandStartIndex);
            faces[faceCount+1].verts[2] = (WORD) (i + TopBandStartIndex);

            faces[faceCount+1].norms[0] = faces[faceCount+1].verts[0];
            faces[faceCount+1].norms[1] = faces[faceCount+1].verts[1];
            faces[faceCount+1].norms[2] = faces[faceCount+1].verts[2];

            faces[faceCount+1].uvs[0] = faces[faceCount+1].verts[0];
            faces[faceCount+1].uvs[1] = faces[faceCount+1].verts[1];
            faces[faceCount+1].uvs[2] = faces[faceCount+1].verts[2];
            faces[faceCount+1].buckyIndex = 0;

            if (dowrap == 1)
            {
                c1 = (F32) i / (F32) BandsX2;
                c2 = (F32) (i + 1) / (F32) BandsX2;

                uvs[faces[faceCount].verts[0]].u = c1;
                uvs[faces[faceCount].verts[0]].v = r1;

                uvs[faces[faceCount].verts[1]].u = c2;
                uvs[faces[faceCount].verts[1]].v = r1;

                uvs[faces[faceCount].verts[2]].u = c2;
                uvs[faces[faceCount].verts[2]].v = r2;

                uvs[faces[faceCount+1].verts[0]].u = c2;
                uvs[faces[faceCount+1].verts[0]].v = r2;

                uvs[faces[faceCount+1].verts[1]].u = c1;
                uvs[faces[faceCount+1].verts[1]].v = r2;

                uvs[faces[faceCount+1].verts[2]].u = c1;
                uvs[faces[faceCount+1].verts[2]].v = r1;
            }
            else
            {
                uvs[faces[faceCount].verts[0]].u = 1.0f;
                uvs[faces[faceCount].verts[0]].v = 0.0f;

                uvs[faces[faceCount].verts[1]].u = 0.0f;
                uvs[faces[faceCount].verts[1]].v = 0.0f;

                uvs[faces[faceCount].verts[2]].u = 0.0f;
                uvs[faces[faceCount].verts[2]].v = 1.0f;

                uvs[faces[faceCount+1].verts[0]].u = 0.0f;
                uvs[faces[faceCount+1].verts[0]].v = 1.0f;

                uvs[faces[faceCount+1].verts[1]].u = 1.0f;
                uvs[faces[faceCount+1].verts[1]].v = 1.0f;

                uvs[faces[faceCount+1].verts[2]].u = 1.0f;
                uvs[faces[faceCount+1].verts[2]].v = 0.0f;
            }
        }
    }

    // bottom band
//	LastBandStartIndex = BandsX2 * (bands - 2) + 1;
    LastBandStartIndex = (BandsX2 + 1) * (bands - 2) + 1;
    r1 = (F32) (bands - 1) / (F32) bands;
    r2 = 1.0f;
    for (i = 0; i < BandsX2; i++, faceCount++)
    {
        faces[faceCount].verts[0] = (WORD) LastIndex;
        faces[faceCount].verts[1] = (WORD) (LastBandStartIndex + i);
//		faces[faceCount].verts[2] = LastBandStartIndex + ((i + 1) % BandsX2);
        faces[faceCount].verts[2] = (WORD) (LastBandStartIndex + ((i + 1) % (BandsX2 + 1)));

        faces[faceCount].norms[0] = faces[faceCount].verts[0];
        faces[faceCount].norms[1] = faces[faceCount].verts[1];
        faces[faceCount].norms[2] = faces[faceCount].verts[2];

        faces[faceCount].uvs[0] = faces[faceCount].verts[0];
        faces[faceCount].uvs[1] = faces[faceCount].verts[1];
        faces[faceCount].uvs[2] = faces[faceCount].verts[2];
        faces[faceCount].buckyIndex = 0;

        if (dowrap == 1)
        {
            c1 = (F32) i / (F32) BandsX2;
            c2 = (F32) (i + 1) / (F32) BandsX2;
            c0 = c1 - 0.5f / (F32) BandsX2;

            uvs[faces[faceCount].verts[0]].u = c0;
            uvs[faces[faceCount].verts[0]].v = r2;

            uvs[faces[faceCount].verts[1]].u = c1;
            uvs[faces[faceCount].verts[1]].v = r1;

            uvs[faces[faceCount].verts[2]].u = c2;
            uvs[faces[faceCount].verts[2]].v = r1;
        }
        else
        {
            uvs[faces[faceCount].verts[0]].u = 0.5f;
            uvs[faces[faceCount].verts[0]].v = 0.0f;

            uvs[faces[faceCount].verts[1]].u = 0.0f;
            uvs[faces[faceCount].verts[1]].v = 1.0f;

            uvs[faces[faceCount].verts[2]].u = 1.0f;
            uvs[faces[faceCount].verts[2]].v = 1.0f;
        }
    }
    delete [] rads;

    root->Setup();

    // setup up face plane equations
    //
    root->SetupPlanes();

    if (!SetupRoot(*root, root->GetName()))
    {
        delete root;
        root = NULL;
    }
    return root;
}