matsyswin.cpp

hl2 source code. Do not use it illegal.

			{
				if (event->modifiers & mxEvent::KeyShift)
				{
					g_viewerSettings.trans[1] = oldty - (float) ((short)event->x - oldx);
					g_viewerSettings.trans[2] = oldtz + (float) ((short)event->y - oldy);
				}
				else if (event->modifiers & mxEvent::KeyCtrl)
				{
					float ry = (float) (event->y - oldy);
					float rx = (float) (event->x - oldx);
					oldx = event->x;
					oldy = event->y;
					
					QAngle movement = QAngle( ry, rx, 0 );
					
					matrix3x4_t tmp1, tmp2, tmp3;
					AngleMatrix( g_viewerSettings.lightrot, tmp1 );
					AngleMatrix( movement, tmp2 );
					ConcatTransforms( tmp2, tmp1, tmp3 );
					MatrixAngles( tmp3, g_viewerSettings.lightrot );
				}
				else
				{
					if (!g_viewerSettings.rotating)
					{
						float ry = (float) (event->y - oldy);
						float rx = (float) (event->x - oldx);
						oldx = event->x;
						oldy = event->y;
						
						QAngle movement;
						matrix3x4_t tmp1, tmp2, tmp3;
						
						movement = QAngle( 0, rx, 0 );
						AngleMatrix( g_viewerSettings.rot, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp1, tmp2, tmp3 );
						MatrixAngles( tmp3, g_viewerSettings.rot );
						
						movement = QAngle( ry, 0, 0 );
						AngleMatrix( g_viewerSettings.rot, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp2, tmp1, tmp3 );
						MatrixAngles( tmp3, g_viewerSettings.rot );
					}
					else
					{
						float ang1 = (180 / 3.1415) * atan2( oldx - w()/2.0, oldy - h()/2.0 );
						float ang2 = (180 / 3.1415) * atan2( event->x - w()/2.0, event->y - h()/2.0 );
						oldx = event->x;
						oldy = event->y;
						
						QAngle movement = QAngle( 0, 0, ang2 - ang1 );
						
						matrix3x4_t tmp1, tmp2, tmp3;
						AngleMatrix( g_viewerSettings.rot, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp2, tmp1, tmp3 );
						MatrixAngles( tmp3, g_viewerSettings.rot );
					}			
				}
			}
			else if (event->buttons & mxEvent::MouseRightButton)
			{
				g_viewerSettings.trans[0] = oldtx + (float) ((short)event->y - oldy);
				g_viewerSettings.trans[0] = clamp( g_viewerSettings.trans[0], 8.0f, 1024.0f );
			}
			redraw ();

			iret = 1;
		}
		break;

	case mxEvent::KeyDown:
		{
			iret = 1;
			switch (event->key)
			{
			default:
				iret = 0;
				break;
			case 116: // F5
				{
					g_MDLViewer->Refresh();
				}
				break;
			case 32:
				{
					int iSeq = models->GetActiveStudioModel()->GetSequence ();
					if (iSeq == models->GetActiveStudioModel()->SetSequence (iSeq + 1))
					{
						models->GetActiveStudioModel()->SetSequence (0);
					}
				}
				break;
				
			case 27:
				if (!getParent ()) // fullscreen mode ?
					mx::quit ();
				break;
				
			case 'g':
				g_viewerSettings.showGround = !g_viewerSettings.showGround;
				break;
				
			case 'h':
				g_viewerSettings.showHitBoxes = !g_viewerSettings.showHitBoxes;
				break;
				
			case 'o':
				g_viewerSettings.showBones = !g_viewerSettings.showBones;
				break;
				
			case 'b':
				g_viewerSettings.showBackground = !g_viewerSettings.showBackground;
				break;
				
			case 'm':
				g_viewerSettings.showMovement = !g_viewerSettings.showMovement;
				break;
				
			case '1':
			case '2':
			case '3':
			case '4':
				g_viewerSettings.renderMode = event->key - '1';
				break;
				
			case '-':
				g_viewerSettings.speedScale -= 0.1f;
				if (g_viewerSettings.speedScale < 0.0f)
					g_viewerSettings.speedScale = 0.0f;
				break;
				
			case '+':
				g_viewerSettings.speedScale += 0.1f;
				if (g_viewerSettings.speedScale > 5.0f)
					g_viewerSettings.speedScale = 5.0f;
				break;
			}
		}
		break;
	} // switch (event->event)

	return iret;
}



void
drawFloor ()
{
	float mTempModel[4][4];
	float mTempView[4][4];
	g_pMaterialSystem->Bind(g_materialFloor);
	g_pMaterialSystem->MatrixMode(MATERIAL_MODEL);
	g_pMaterialSystem->GetMatrix(MATERIAL_MODEL, (float*)mTempModel);
	g_pMaterialSystem->LoadIdentity();
	g_pMaterialSystem->MatrixMode(MATERIAL_VIEW);
	g_pMaterialSystem->GetMatrix(MATERIAL_VIEW, (float*)mTempView);
	g_pMaterialSystem->LoadIdentity();
	{
		IMesh* pMesh = g_pMaterialSystem->GetDynamicMesh();
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

		float dist=-15000.0f;
		float tMin=0, tMax=1;
		
		meshBuilder.Position3f(-dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f(-dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.End();
		pMesh->Draw();
	}
	g_pMaterialSystem->MatrixMode(MATERIAL_MODEL);
	g_pMaterialSystem->LoadMatrix((float*)mTempModel);
	g_pMaterialSystem->MatrixMode(MATERIAL_VIEW);
	g_pMaterialSystem->LoadMatrix((float*)mTempView);
}



void
setupRenderMode ()
{
}

void MatSysWindow::SuppressBufferSwap( bool bSuppress )
{
	m_bSuppressSwap = bSuppress;
}

void MatSysWindow::draw ()
{
	int i;

	g_pMaterialSystem->BeginFrame();
	CUtlVector< StudioModel * > modellist;

	modellist.AddToTail( models->GetActiveStudioModel() );

	if ( models->CountVisibleModels() > 0 )
	{
		modellist.RemoveAll();
		for ( i = 0; i < models->Count(); i++ )
		{
			if ( models->IsModelShownIn3DView( i ) )
			{
				modellist.AddToTail( models->GetStudioModel( i ) );
			}
		}
	}

	g_pMaterialSystem->ClearBuffers(true, true);

	int captiony = GetCaptionHeight();
	int viewh = h2() - captiony;

	g_pMaterialSystem->Viewport( 0, captiony, w2(), viewh );

	g_pMaterialSystem->MatrixMode( MATERIAL_PROJECTION );
	g_pMaterialSystem->LoadIdentity( );
	g_pMaterialSystem->PerspectiveX(20.0f, (float)w2() / (float)viewh, 1.0f, 20000.0f);
	
	g_pMaterialSystem->MatrixMode( MATERIAL_VIEW );
	g_pMaterialSystem->LoadIdentity( );
	// FIXME: why is this needed?  Doesn't SetView() override this?
	g_pMaterialSystem->Rotate( -90,  1, 0, 0 );	    // put Z going up
	g_pMaterialSystem->Rotate( -90,  0, 0, 1 );

	ViewerSettings oldsettings = g_viewerSettings;

	int modelcount = modellist.Count();
	int countover2 = modelcount / 2;
	int ydelta = g_pControlPanel->GetModelGap();
	int yoffset = -countover2 * ydelta;
	for ( i = 0 ; i < modelcount; i++ )
	{
		g_viewerSettings.trans[ 1 ] = oldsettings.trans[ 1 ] + yoffset;
		yoffset += ydelta;

		modellist[ i ]->GetStudioRender()->BeginFrame();
		modellist[ i ]->DrawModel();
		modellist[ i ]->GetStudioRender()->EndFrame();
	}

	g_viewerSettings = oldsettings;

	//
	// draw ground
	//
	if (g_viewerSettings.showGround)
	{
		drawFloor ();
	}

	if (!m_bSuppressSwap)
	{
		g_pMaterialSystem->SwapBuffers();
	}

	g_pMaterialSystem->EndFrame();
}

void MatSysWindow::TakeSnapshotRect( const char *pFilename, int x, int y, int w, int h )
{
	int i;
	HANDLE hf;
	BITMAPFILEHEADER hdr;
	BITMAPINFOHEADER bi;
	DWORD dwTmp, imageSize;
	byte *hp, b, *pBlue, *pRed;

	w = ( w + 3 ) & ~3;

	imageSize = w * h * 3;
	// Create the file
	hf = CreateFile( pFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
	if( hf == INVALID_HANDLE_VALUE )
	{
		return;
	}

	// file header
	hdr.bfType = 0x4d42;	// 'BM'
	hdr.bfSize = (DWORD) ( sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + imageSize );
	hdr.bfReserved1 = 0;
	hdr.bfReserved2 = 0;
	hdr.bfOffBits = (DWORD) ( sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) );

	if( !WriteFile( hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write file header to snapshot.\n" );

	// bitmap header
	bi.biSize = sizeof(BITMAPINFOHEADER);
	bi.biWidth = w;
	bi.biHeight = h;
	bi.biPlanes = 1;
	bi.biBitCount = 24;
	bi.biCompression = BI_RGB;
	bi.biSizeImage = 0;	//vid.rowbytes * vid.height;
	bi.biXPelsPerMeter = 0;
	bi.biYPelsPerMeter = 0;
	bi.biClrUsed = 0;
	bi.biClrImportant = 0;

	if( !WriteFile( hf, (LPVOID) &bi, sizeof(BITMAPINFOHEADER), (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write bitmap header to snapshot.\n" );

	// bitmap bits
	hp = (byte *) malloc(imageSize);
	
	if (hp == NULL)
		Error( "Couldn't allocate bitmap header to snapshot.\n" );

	// Get Bits from GL
	g_pMaterialSystem->ReadPixels( x, y, w, h, hp, IMAGE_FORMAT_RGB888 );

	// Invert vertically for BMP format
	for (i = 0; i < h / 2; i++)
	{
		byte *top = hp + i * w * 3;
		byte *bottom = hp + (h - i - 1) * w * 3;
		for (int j = 0; j < w * 3; j++)
		{
			b = *top;
			*top = *bottom;
			*bottom = b;
			top++;
			bottom++;
		}
	}

	// Reverse Red and Blue
	pRed = hp;
	pBlue = pRed + 2;
	for(i = 0; i < w * h;i++)
	{
		b = *pRed;
		*pRed = *pBlue;
		*pBlue = b;
		pBlue += 3;
		pRed += 3;
	}

	if( !WriteFile( hf, (LPVOID)hp, imageSize, (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write bitmap data snapshot.\n" );

	free(hp);

	// clean up
	if( !CloseHandle( hf ) )
		Error( "Couldn't close file for snapshot.\n" );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool MatSysWindow::IsSuppressingResize( void )
{
	return m_bSuppressResize;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : suppress - 
//-----------------------------------------------------------------------------
void MatSysWindow::SuppressResize( bool suppress )
{
	m_bSuppressResize = suppress;
}