自学教程：C++ Brush_Build函数代码示例

void Select_ScaleTexture(int x, int y){	brush_t		*b;	face_t		*f;	if(selected_brushes.next == &selected_brushes && selected_face == NULL)	{		return;	}  for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{		for (f=b->brush_faces ; f ; f=f->next)		{			f->texdef.scale[0] += x;			f->texdef.scale[1] += y;		}		Brush_Build(b);    if (b->patchBrush)      Patch_ScaleTexture(b->nPatchID, x, y);	}	if (selected_face)	{		selected_face->texdef.scale[0] += x;		selected_face->texdef.scale[1] += y;		Brush_Build(selected_face_brush);	}	Sys_UpdateWindows (W_CAMERA);}

void Select_FitTexture( int nHeight, int nWidth ){	brush_s*        b;		int nFaceCount = g_ptrSelectedFaces.GetSize();		if ( selected_brushes.next == &selected_brushes && nFaceCount == 0 )		return;			for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )	{		Brush_FitTexture( b, nHeight, nWidth );		Brush_Build( b );	}		if ( nFaceCount > 0 )	{		for ( int i = 0; i < nFaceCount; i++ )		{			face_s* selFace = reinterpret_cast<face_s*>( g_ptrSelectedFaces.GetAt( i ) );			brush_s* selBrush = reinterpret_cast<brush_s*>( g_ptrSelectedFaceBrushes.GetAt( i ) );			Face_FitTexture( selFace, nHeight, nWidth );			Brush_Build( selBrush );		}	}		Sys_UpdateWindows( W_CAMERA );}

void Select_RotateTexture(int amt){	brush_t		*b;	face_t		*f;	if(selected_brushes.next == &selected_brushes && selected_face == NULL)		return;  for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{		for (f=b->brush_faces ; f ; f=f->next)		{			f->texdef.rotate += amt;      f->texdef.rotate = static_cast<int>(f->texdef.rotate) % 360;		}		Brush_Build(b);    if (b->patchBrush)      Patch_RotateTexture(b->nPatchID, amt);	}	  if (selected_face)	{		selected_face->texdef.rotate += amt;    selected_face->texdef.rotate = static_cast<int>(selected_face->texdef.rotate) % 360;		Brush_Build(selected_face_brush);	}	Sys_UpdateWindows (W_CAMERA);}

void Select_ShiftTexture( int x, int y ){	brush_s*        b;	face_s*     f;		int nFaceCount = g_ptrSelectedFaces.GetSize();		if ( selected_brushes.next == &selected_brushes && nFaceCount == 0 )		return;			for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )	{		for ( f = b->brush_faces ; f ; f = f->next )		{			if ( g_qeglobals.m_bBrushPrimitMode )			{				// use face normal to compute a true translation				Select_ShiftTexture_BrushPrimit( f, x, y );			}			else			{				f->texdef.shift[0] += x;				f->texdef.shift[1] += y;			}		}		Brush_Build( b );		if ( b->patchBrush )		{			//Patch_ShiftTexture(b->nPatchID, x, y);			Patch_ShiftTexture( b->pPatch, x, y );		}	}		if ( nFaceCount > 0 )	{		for ( int i = 0; i < nFaceCount; i++ )		{			face_s* selFace = reinterpret_cast<face_s*>( g_ptrSelectedFaces.GetAt( i ) );			brush_s* selBrush = reinterpret_cast<brush_s*>( g_ptrSelectedFaceBrushes.GetAt( i ) );			if ( g_qeglobals.m_bBrushPrimitMode )			{							// use face normal to compute a true translation				// Select_ShiftTexture_BrushPrimit( selected_face, x, y );				// use camera view to compute texture shift				g_pParentWnd->GetCamera()->ShiftTexture_BrushPrimit( selFace, x, y );			}			else			{				selFace->texdef.shift[0] += x;				selFace->texdef.shift[1] += y;			}			Brush_Build( selBrush );		}	}		Sys_UpdateWindows( W_CAMERA );}

void RotateTextures(int nAxis, float fDeg, vec3_t vOrigin){	for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{    for (face_t* f=b->brush_faces ; f ; f=f->next)		{      RotateFaceTexture(f, nAxis, fDeg);      Brush_Build(b, false);    }    Brush_Build(b, false);	}}

/*	Turn the currently selected entity back into normal brushes*/void  Select_Ungroup (void){	entity_t	*e;	brush_t		*b;	e = selected_brushes.next->owner;	if (!e || e == world_entity || e->eclass->fixedsize)	{		Sys_Status ("Not a grouped entity.", 0);		return;	}	for (b=e->brushes.onext ; b != &e->brushes ; b=e->brushes.onext)	{		Brush_RemoveFromList (b);		Brush_AddToList (b, &active_brushes);		Entity_UnlinkBrush (b);		Entity_LinkBrush (world_entity, b);		Brush_Build( b );		b->owner = world_entity;	}	Entity_Free (e);	Sys_UpdateWindows (W_ALL);}

void SI_FaceList_FitTexture(texdef_to_face_t* si_texdef_face_list, int nHeight, int nWidth){    texdef_to_face_t* temp_texdef_face_list;    brushprimit_texdef_t bp;    if (!si_texdef_face_list)        return;    for (temp_texdef_face_list = si_texdef_face_list; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)    {        Face_FitTexture(temp_texdef_face_list->face, nHeight, nWidth);        Brush_Build(temp_texdef_face_list->brush,true,true,false,false);        // Write changes to our working Texdef list        if(g_qeglobals.m_bBrushPrimitMode)        {            ConvertTexMatWithQTexture(&temp_texdef_face_list->face->brushprimit_texdef, QERApp_Shader_ForName( temp_texdef_face_list->face->texdef.GetName() )->getTexture(), &bp, NULL);            TexMatToFakeTexCoords(bp.coords, temp_texdef_face_list->face->texdef.shift, &temp_texdef_face_list->face->texdef.rotate, temp_texdef_face_list->face->texdef.scale);        }        temp_texdef_face_list->texdef = temp_texdef_face_list->face->texdef;    }    Sys_UpdateWindows (W_CAMERA);}

void Select_AplyMatrix (void){	brush_t	*b;	face_t	*f;	int		i, j;	vec3_t	temp;	for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{		for (f=b->brush_faces ; f ; f=f->next)		{			for (i=0 ; i<3 ; i++)			{				Math_VectorSubtract(f->planepts[i],select_origin, temp);				for (j=0 ; j<3 ; j++)					f->planepts[i][j] = Math_DotProduct(temp,select_matrix[j])						+ select_origin[j];			}			if (select_fliporder)			{				Math_VectorCopy(f->planepts[0],temp);				Math_VectorCopy(f->planepts[2],f->planepts[0]);				Math_VectorCopy(temp,f->planepts[2]);			}		}		Brush_Build( b );	}	Sys_UpdateWindows (W_ALL);}

void FindReplaceTextures( const char* pFind, const char* pReplace, bool bSelected, bool bForce ){	brush_s* pList = ( bSelected ) ? &selected_brushes : &active_brushes;	if ( !bSelected )	{		Select_Deselect();	}		for ( brush_s* pBrush = pList->next ; pBrush != pList; pBrush = pBrush->next )	{		if ( pBrush->patchBrush )		{			Patch_FindReplaceTexture( pBrush, pFind, pReplace, bForce );		}				for ( face_s* pFace = pBrush->brush_faces; pFace; pFace = pFace->next )		{			if ( bForce || strcmpi( pFace->texdef.name, pFind ) == 0 )			{				pFace->d_texture = Texture_ForName( pReplace );				//strcpy(pFace->texdef.name, pReplace);				pFace->texdef.SetName( pReplace );			}		}		Brush_Build( pBrush );	}	Sys_UpdateWindows( W_CAMERA );}

/*============Select_SetTextureTimo : bFitScale to compute scale on the plane and counteract plane / axial plane snappingTimo :  brush primitive texturing        the brushprimit_texdef given must be understood as a qtexture_t width=2 height=2 ( HiRes )Timo :  texture plugin, added an IPluginTexdef* parameter        must be casted to an IPluginTexdef!        if not NULL, get ->Copy() of it into each face or brush ( and remember to hook )        if NULL, means we have no information, ask for a default============*/void WINAPI Select_SetTexture( texdef_t* texdef, brushprimit_texdef_s* brushprimit_texdef, bool bFitScale, void* pPlugTexdef ){	brush_s*    b;	int nCount = g_ptrSelectedFaces.GetSize();	if ( nCount > 0 )	{		Undo_Start( "set face textures" );		ASSERT( g_ptrSelectedFaces.GetSize() == g_ptrSelectedFaceBrushes.GetSize() );		for ( int i = 0; i < nCount; i++ )		{			face_s* selFace = reinterpret_cast<face_s*>( g_ptrSelectedFaces.GetAt( i ) );			brush_s* selBrush = reinterpret_cast<brush_s*>( g_ptrSelectedFaceBrushes.GetAt( i ) );			Undo_AddBrush( selBrush );			SetFaceTexdef( selBrush, selFace, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef*>( pPlugTexdef ) );			Brush_Build( selBrush, bFitScale );			Undo_EndBrush( selBrush );		}		Undo_End();	}	else if ( selected_brushes.next != &selected_brushes )	{		Undo_Start( "set brush textures" );		for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )			if ( !b->owner->eclass->fixedsize )			{				Undo_AddBrush( b );				Brush_SetTexture( b, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef*>( pPlugTexdef ) );				Undo_EndBrush( b );			}		Undo_End();	}	Sys_UpdateWindows( W_ALL );}

void Select_AplyMatrix (bool bSnap){	brush_t	*b;	face_t	*f;	int		i, j;	vec3_t	temp;	for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{    for (f=b->brush_faces ; f ; f=f->next)	  {		  for (i=0 ; i<3 ; i++)			{			  VectorSubtract (f->planepts[i], select_origin, temp);				for (j=0 ; j<3 ; j++)				  f->planepts[i][j] = DotProduct(temp, select_matrix[j]) + select_origin[j];			}			if (select_fliporder)			{			  VectorCopy (f->planepts[0], temp);				VectorCopy (f->planepts[2], f->planepts[0]);				VectorCopy (temp, f->planepts[2]);			}    }		Brush_Build(b, bSnap);    if (b->patchBrush)    {      Patch_ApplyMatrix(b->nPatchID, select_origin, select_matrix);    }	}}

/* =======================================================================================================================    AddRegionBrushes a regioned map will have temp walls put up at the region boundary ======================================================================================================================= */void AddRegionBrushes(void){	idVec3		mins, maxs;	int			i;	texdef_t	td;	if (!region_active) {		return;	}	memset(&td, 0, sizeof(td));	td = g_qeglobals.d_texturewin.texdef;	// strcpy (td.name, "REGION");	td.SetName("textures/REGION");	const int REGION_WIDTH = 1024;	mins[0] = region_mins[0] - REGION_WIDTH;	maxs[0] = region_mins[0] + 1;	mins[1] = region_mins[1] - REGION_WIDTH;	maxs[1] = region_maxs[1] + REGION_WIDTH;	mins[2] = MIN_WORLD_COORD;	maxs[2] = MAX_WORLD_COORD;	region_sides[0] = Brush_Create(mins, maxs, &td);	mins[0] = region_maxs[0] - 1;	maxs[0] = region_maxs[0] + REGION_WIDTH;	region_sides[1] = Brush_Create(mins, maxs, &td);	mins[0] = region_mins[0] - REGION_WIDTH;	maxs[0] = region_maxs[0] + REGION_WIDTH;	mins[1] = region_mins[1] - REGION_WIDTH;	maxs[1] = region_mins[1] + 1;	region_sides[2] = Brush_Create(mins, maxs, &td);	mins[1] = region_maxs[1] - 1;	maxs[1] = region_maxs[1] + REGION_WIDTH;	region_sides[3] = Brush_Create(mins, maxs, &td);	mins = region_mins;	maxs = region_maxs;	maxs[2] = mins[2] + REGION_WIDTH;	region_sides[4] = Brush_Create(mins, maxs, &td);	mins = region_mins;	maxs = region_maxs;	mins[2] = maxs[2] - REGION_WIDTH;	region_sides[5] = Brush_Create(mins, maxs, &td);	for (i = 0; i < 6; i++) {		Brush_AddToList(region_sides[i], &selected_brushes);		Entity_LinkBrush(world_entity, region_sides[i]);		Brush_Build(region_sides[i]);	}}

void Brush_SetTexture(brush_t *b,texdef_t *texdef){	face_t	*f;	for (f=b->brush_faces ; f ; f=f->next)		f->texdef = *texdef;	Brush_Build(b);}

//Timo : another version with bConvert flag//++timo since 1.7 is not compatible with earlier plugin versions, remove this one and update QERApp_BuildBrushvoid WINAPI QERApp_BuildBrush2 (LPVOID pv, int bConvert){	AFX_MANAGE_STATE(AfxGetStaticModuleState());	brush_t *pBrush = g_pParentWnd->GetPlugInMgr().FindBrushHandle(pv);	if (pBrush != NULL)	{		Brush_Build( pBrush, true, true, bConvert );		Sys_UpdateWindows(W_ALL);	}}

// creates a dummy brush in the active brushes list// FIXME : is this one really USED ?void WINAPI QERApp_CreateBrush(vec3_t vMin, vec3_t vMax){	AFX_MANAGE_STATE(AfxGetStaticModuleState());		brush_t* pBrush = Brush_Create(vMin, vMax, &g_qeglobals.d_texturewin.texdef);	Entity_LinkBrush (world_entity, pBrush);	Brush_Build(pBrush);	Brush_AddToList (pBrush, &active_brushes);	Select_Brush(pBrush);	Sys_UpdateWindows(W_ALL);}

void Brush_Move (brush_t *b, vec3_t move){	int		i;	face_t	*f;	for (f=b->brush_faces ; f ; f=f->next)		for (i=0 ; i<3 ; i++)			Math_VectorAdd(f->planepts[i],move,f->planepts[i]);	Brush_Build(b);}

void Select_FitTexture(int nHeight, int nWidth){	brush_t		*b;	if(selected_brushes.next == &selected_brushes && selected_face == NULL)		return;  for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{    Brush_FitTexture(b, nHeight, nWidth);		Brush_Build(b);	}	if (selected_face)	{    Face_FitTexture(selected_face, nHeight, nWidth);		Brush_Build(selected_face_brush);	}	Sys_UpdateWindows (W_CAMERA);}

/* =======================================================================================================================    AddProp ======================================================================================================================= */void CEntityDlg::AddProp() {	if( editEntity == NULL ) {		return;	}	CString Key, Value;	editKey.GetWindowText( Key );	editVal.GetWindowText( Value );	bool isName = ( stricmp( Key, "name" ) == 0 );	bool isModel = static_cast<bool>( ( stricmp( Key, "model" ) == 0 && Value.GetLength() > 0 ) );	bool isOrigin = ( idStr::Icmp( Key, "origin" ) == 0 );	if( multipleEntities ) {		brush_t *b;		for( b = selected_brushes.next; b != &selected_brushes; b = b->next ) {			if( isName ) {				Entity_SetName( b->owner, Value );			} else {				if( !( ( isModel || isOrigin ) && ( b->owner->eclass->nShowFlags & ECLASS_WORLDSPAWN ) ) ) {					SetKeyValue( b->owner, Key, Value );				}			}		}	} else {		if( isName ) {			Entity_SetName( editEntity, Value );		} else {			if( !( ( isModel || isOrigin ) && ( editEntity->eclass->nShowFlags & ECLASS_WORLDSPAWN ) ) ) {				SetKeyValue( editEntity, Key, Value );			}		}		if( isModel && !( editEntity->eclass->nShowFlags & ECLASS_WORLDSPAWN ) ) {			idBounds	bo;			idVec3	mins, maxs;			selected_brushes.next->modelHandle = renderModelManager->FindModel( Value );			if( dynamic_cast<idRenderModelPrt *>( selected_brushes.next->modelHandle ) || dynamic_cast<idRenderModelLiquid *>( selected_brushes.next->modelHandle ) ) {				bo.Zero();				bo.ExpandSelf( 12.0f );			} else {				bo = selected_brushes.next->modelHandle->Bounds( NULL );			}			VectorCopy( bo[0], mins );			VectorCopy( bo[1], maxs );			VectorAdd( mins, editEntity->origin, mins );			VectorAdd( maxs, editEntity->origin, maxs );			Brush_RebuildBrush( selected_brushes.next, mins, maxs, false );			Brush_Build( selected_brushes.next , false, false , false, true );		}	}	// refresh the prop listbox	SetKeyValPairs();	Sys_UpdateWindows( W_ALL );}

void Select_ApplyMatrix( bool bSnap, bool bRotation, int nAxis, float fDeg ){	brush_s*    b;	face_s* f;	int     i, j;	edVec3_c    temp;		for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )	{		for ( f = b->brush_faces ; f ; f = f->next )		{			for ( i = 0 ; i < 3 ; i++ )			{				temp = f->planepts[i] - select_origin;				for ( j = 0 ; j < 3 ; j++ )					f->planepts[i][j] = temp.dotProduct( select_matrix[j] ) + select_origin[j];			}			if ( select_fliporder )			{				// swap the points				temp = f->planepts[0];				f->planepts[0] = f->planepts[2];				f->planepts[2] = temp;			}		}				//if(b->owner->eclass->fixedsize)		//{		//  if (bRotation && b->owner->md3Class)		//  {		//      b->owner->vRotation[nAxis] += fDeg;		//  }		//}				Brush_Build( b, bSnap );				if ( b->patchBrush )		{			//Patch_ApplyMatrix(b->nPatchID, select_origin, select_matrix);			Patch_ApplyMatrix( b->pPatch, select_origin, select_matrix, bSnap );		}				//if (b->terrainBrush)		//{		//  Terrain_ApplyMatrix(b->pTerrain, select_origin, select_matrix, bSnap);		//}			}}

void Select_ApplyMatrix (bool bSnap, bool bRotation, int nAxis, float fDeg){	brush_t	*b;	face_t	*f;	int		i, j;	vec3_t	temp;	for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{		for (f=b->brush_faces ; f ; f=f->next)		{			for (i=0 ; i<3 ; i++)			{				VectorSubtract (f->planepts[i], select_origin, temp);				for (j=0 ; j<3 ; j++)					f->planepts[i][j] = DotProduct(temp, select_matrix[j]) + select_origin[j];			}			if (select_fliporder)			{				VectorCopy (f->planepts[0], temp);				VectorCopy (f->planepts[2], f->planepts[0]);				VectorCopy (temp, f->planepts[2]);			}		}		if(b->owner->eclass->fixedsize)		{			if (bRotation && b->owner->md3Class)			{				b->owner->vRotation[nAxis] += fDeg;			}		}		Brush_Build(b, bSnap);		if (b->patchBrush)		{			//Patch_ApplyMatrix(b->nPatchID, select_origin, select_matrix);			Patch_ApplyMatrix(b->pPatch, select_origin, select_matrix, bSnap);		}		if (b->terrainBrush)		{			Terrain_ApplyMatrix(b->pTerrain, select_origin, select_matrix, bSnap);		}	}}

void RotateTextures( int nAxis, float fDeg, vec3_t vOrigin ){	for ( brush_s* b = selected_brushes.next ; b != &selected_brushes ; b = b->next )	{		for ( face_s* f = b->brush_faces ; f ; f = f->next )		{			if ( g_qeglobals.m_bBrushPrimitMode )				RotateFaceTexture_BrushPrimit( f, nAxis, fDeg, vOrigin );			else				RotateFaceTexture( f, nAxis, fDeg );			//++timo removed that call .. works fine .. ???????			//          Brush_Build(b, false);		}		Brush_Build( b, false );	}}

/* ======================================================================================================================= ======================================================================================================================= */void Map_BuildBrushData( void ) {	brush_t *b, *next;	if( active_brushes.next == NULL ) {		return;	}	Sys_BeginWait();	// this could take a while	int n = 0;	for( b = active_brushes.next; b != NULL && b != &active_brushes; b = next ) {		next = b->next;		Brush_Build( b, true, false, false );		if( !b->brush_faces || ( g_PrefsDlg.m_bCleanTiny && CheckForTinyBrush( b, n++, g_PrefsDlg.m_fTinySize ) ) ) {			Brush_Free( b );			common->Printf( "Removed degenerate brush/n" );		}	}	Sys_EndWait();}

void Select_Scale(float x, float y, float z){	Select_GetMid (select_origin);	for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)	{		for (face_t* f=b->brush_faces ; f ; f=f->next)		{			for (int i=0 ; i<3 ; i++)			{				f->planepts[i][0] -= select_origin[0];				f->planepts[i][1] -= select_origin[1];				f->planepts[i][2] -= select_origin[2];				f->planepts[i][0] *= x;				//f->planepts[i][0] = floor(f->planepts[i][0] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;				f->planepts[i][1] *= y;				//f->planepts[i][1] = floor(f->planepts[i][1] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;				f->planepts[i][2] *= z;				//f->planepts[i][2] = floor(f->planepts[i][2] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;				f->planepts[i][0] += select_origin[0];				f->planepts[i][1] += select_origin[1];				f->planepts[i][2] += select_origin[2];			}		}		Brush_Build(b, false);		if (b->patchBrush)		{			vec3_t v;			v[0] = x;			v[1] = y;			v[2] = z;			//Patch_Scale(b->nPatchID, select_origin, v);			Patch_Scale(b->pPatch, select_origin, v);		}		if (b->terrainBrush)		{			vec3_t v;			v[0] = x;			v[1] = y;			v[2] = z;			Terrain_Scale(b->pTerrain, select_origin, v);		}	}}

void Select_SetTexture (texdef_t *texdef){	brush_t	*b;	if (selected_face)	{		selected_face->texdef = *texdef;		Brush_Build(selected_face_brush);	}	else	{		for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)			if (!b->owner->eclass->fixedsize)				Brush_SetTexture (b, texdef);	}	Sys_UpdateWindows (W_ALL);}

/*============Select_SetTexturebool bFitScale = compute scale on the plane and counteract plane->axial snapping============*/void Select_SetTexture (texdef_t *texdef, bool bFitScale/*=false*/, bool bNoSystemTextureOverwrite/*=false*/){	brush_t	*b;	if (selected_face)	{		SetFaceTexdef (selected_face_brush, selected_face, texdef, bFitScale, bNoSystemTextureOverwrite);		Brush_Build(selected_face_brush, bFitScale);	}	else	{		for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)			if (!b->owner->eclass->fixedsize)				Brush_SetTexture (b, texdef, bFitScale, bNoSystemTextureOverwrite);	}	Sys_UpdateWindows (W_ALL);}

void CPlugInManager::CommitBrushHandleToMap(void * vp){  g_bScreenUpdates = false;   for (int i = 0; i < m_BrushHandles.GetSize(); i++)  {    brush_t *pb = reinterpret_cast<brush_t*>(m_BrushHandles.GetAt(i));    if (pb == reinterpret_cast<brush_t*>(vp))    {      m_BrushHandles.RemoveAt(i);	  Entity_LinkBrush (world_entity, pb);      Brush_Build(pb);	  Brush_AddToList (pb, &active_brushes);      Select_Brush(pb);    }  }  g_bScreenUpdates = true;   Sys_UpdateWindows(W_ALL);}

/*==============NewBrushDrag==============*/void NewBrushDrag (int x, int y){	vec3_t	mins, maxs, junk;	int		i;	float	temp;	brush_t	*n;	if (!DragDelta (x,y, junk))		return;	// delete the current selection	if (selected_brushes.next != &selected_brushes)		Brush_Free (selected_brushes.next);	XY_ToGridPoint (pressx, pressy, mins);	mins[2] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_bottom_z/g_qeglobals.d_gridsize));	XY_ToGridPoint (x, y, maxs);	maxs[2] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_top_z/g_qeglobals.d_gridsize));	if (maxs[2] <= mins[2])		maxs[2] = mins[2] + g_qeglobals.d_gridsize;	for (i=0 ; i<3 ; i++)	{		if (mins[i] == maxs[i])			return;	// don't create a degenerate brush		if (mins[i] > maxs[i])		{			temp = mins[i];			mins[i] = maxs[i];			maxs[i] = temp;		}	}	n = Brush_Create (mins, maxs, &g_qeglobals.d_texturewin.texdef);	if (!n)		return;	Brush_AddToList (n, &selected_brushes);	Entity_LinkBrush (world_entity, n);	Brush_Build( n );//	Sys_UpdateWindows (W_ALL);	Sys_UpdateWindows (W_XY| W_CAMERA);}

brush_t *AddBrushForTerrain( terrainMesh_t *pm, bool bLinkToWorld ) {	int		j;	vec3_t	vMin;	vec3_t	vMax;	brush_t	*b;	face_t	*f;	// calculate the face normals	Terrain_CalcNormals( pm );   	// find the farthest points in x,y,z	Terrain_CalcBounds( pm, vMin, vMax );	for( j = 0; j < 3; j++ ) {		if ( vMin[ j ] == vMax[ j ] ) {			vMin[ j ] -= 4;			vMax[ j ] += 4;		}	}	b = Brush_Create( vMin, vMax, &pm->heightmap->tri.texdef );	for( f = b->brush_faces; f != NULL; f = f->next ) {		// copy the texdef to the brush faces texdef		f->texdef = pm->heightmap->tri.texdef;	}	// FIXME: this entire type of linkage needs to be fixed	b->pTerrain		= pm;	b->terrainBrush = true;	pm->pSymbiot    = b;	pm->bSelected   = false;	pm->bDirty      = true;	pm->nListID		= -1;	if ( bLinkToWorld ) {		Brush_AddToList( b, &active_brushes );		Entity_LinkBrush( world_entity, b );		Brush_Build( b, true );	}  	return b;}

void CLightDlg::SaveLightInfo(const idDict *differences){	if (com_editorActive) {		// used from Radiant		for (brush_t *b = selected_brushes.next; b && b != &selected_brushes; b = b->next) {			if ((b->owner->eclass->nShowFlags & ECLASS_LIGHT) && !b->entityModel) {				if (differences) {					lightInfo.ToDictFromDifferences(&b->owner->epairs, differences);				} else {					lightInfo.ToDict(&b->owner->epairs);				}				Brush_Build(b);			}		}	} else {		// used in-game		idList<idEntity *> list;		list.SetNum(128);		int count = gameEdit->GetSelectedEntities(list.Ptr(), list.Num());		list.SetNum(count);		for (int i = 0; i < count; i++) {			if (differences) {				gameEdit->EntityChangeSpawnArgs(list[i], differences);				gameEdit->EntityUpdateChangeableSpawnArgs(list[i], NULL);			} else {				idDict newArgs;				lightInfo.ToDict(&newArgs);				gameEdit->EntityChangeSpawnArgs(list[i], &newArgs);				gameEdit->EntityUpdateChangeableSpawnArgs(list[i], NULL);			}			gameEdit->EntityUpdateVisuals(list[i]);		}	}}