656 lines
16 KiB
C++
656 lines
16 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
|
|
#include "../../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../radiant/QE3.H"
|
|
#include "MaterialPreviewView.h"
|
|
|
|
|
|
// MaterialPreviewView
|
|
IMPLEMENT_DYNCREATE(MaterialPreviewView, CView)
|
|
|
|
MaterialPreviewView::MaterialPreviewView() {
|
|
// Initialize the rendered material
|
|
renderedView.setMedia( "_default" );
|
|
}
|
|
|
|
MaterialPreviewView::~MaterialPreviewView() {
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(MaterialPreviewView, CView)
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
// MaterialPreviewView drawing
|
|
|
|
void MaterialPreviewView::OnDraw(CDC* pDC) {
|
|
}
|
|
|
|
// MaterialPreviewView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void MaterialPreviewView::AssertValid() const {
|
|
CView::AssertValid();
|
|
}
|
|
|
|
void MaterialPreviewView::Dump(CDumpContext& dc) const {
|
|
CView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
// MaterialPreviewView message handlers
|
|
|
|
int MaterialPreviewView::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
if (CView::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
DWORD dwStyle;
|
|
CRect rc;
|
|
|
|
dwStyle = WS_CHILD|WS_VISIBLE;
|
|
|
|
// Init the control's size to cover the entire client area
|
|
GetClientRect(rc);
|
|
|
|
// Initialize the rendered window and material
|
|
renderWindow.Create( NULL, "renderWindow", dwStyle, rc, this, 1010 );
|
|
|
|
renderWindow.setDrawable( &renderedView );
|
|
renderWindow.SetWindowPos(NULL, 0, 0, rc.Width(), rc.Height(), SWP_SHOWWINDOW);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void MaterialPreviewView::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CRect rc;
|
|
|
|
CView::OnSize( nType, cx, cy );
|
|
|
|
GetClientRect( rc );
|
|
|
|
renderWindow.SetWindowPos(NULL, 0, 0, rc.Width(), rc.Height(), SWP_SHOWWINDOW);
|
|
renderWindow.Invalidate();
|
|
renderWindow.RedrawWindow();
|
|
}
|
|
|
|
void MaterialPreviewView::MV_OnMaterialSelectionChange( MaterialDoc *pMaterial )
|
|
{
|
|
if ( pMaterial && pMaterial->renderMaterial ) {
|
|
|
|
currentMaterial = pMaterial->renderMaterial->GetName();
|
|
renderedView.setMedia( currentMaterial );
|
|
|
|
renderWindow.Invalidate();
|
|
renderWindow.RedrawWindow();
|
|
}
|
|
}
|
|
|
|
void MaterialPreviewView::OnLocalParmChange( int parmNum, float value ) {
|
|
|
|
renderedView.setLocalParm( parmNum, value );
|
|
}
|
|
|
|
void MaterialPreviewView::OnGlobalParmChange( int parmNum, float value ) {
|
|
|
|
renderedView.setGlobalParm( parmNum, value );
|
|
}
|
|
|
|
void MaterialPreviewView::OnLightShaderChange( int lightId, idStr shaderName ) {
|
|
|
|
renderedView.setLightShader( lightId, shaderName );
|
|
}
|
|
|
|
void MaterialPreviewView::OnLightColorChange( int lightId, idVec3 &color ) {
|
|
|
|
renderedView.setLightColor( lightId, color );
|
|
}
|
|
|
|
void MaterialPreviewView::OnLightRadiusChange( int lightId, float radius ) {
|
|
|
|
renderedView.setLightRadius( lightId, radius );
|
|
}
|
|
|
|
void MaterialPreviewView::OnLightAllowMoveChange( int lightId, bool move ) {
|
|
|
|
renderedView.setLightAllowMove( lightId, move );
|
|
}
|
|
|
|
void MaterialPreviewView::OnAddLight( void ) {
|
|
|
|
renderedView.addLight();
|
|
}
|
|
|
|
void MaterialPreviewView::OnDeleteLight( int lightId ) {
|
|
|
|
renderedView.deleteLight( lightId );
|
|
}
|
|
|
|
void MaterialPreviewView::OnModelChange( int modelId ) {
|
|
|
|
renderedView.setObject( modelId );
|
|
}
|
|
|
|
void MaterialPreviewView::OnCustomModelChange( idStr modelName ) {
|
|
|
|
renderedView.setCustomModel( modelName );
|
|
}
|
|
|
|
void MaterialPreviewView::OnShowLightsChange( bool showLights ) {
|
|
|
|
renderedView.setShowLights( showLights );
|
|
}
|
|
|
|
/*
|
|
=============================================================================
|
|
=============================================================================
|
|
=============================================================================
|
|
*/
|
|
|
|
extern bool Sys_KeyDown(int key);
|
|
extern float fDiff(float f1, float f2);
|
|
|
|
idGLDrawableView::idGLDrawableView() {
|
|
material = NULL;
|
|
modelDefHandle = -1;
|
|
|
|
objectId = 0;
|
|
showLights = true;
|
|
realTime = 16;
|
|
|
|
viewOrigin.Set( 0.f, 0.f, 0.f );
|
|
viewRotation.Set( 0.f, 0.f, 0.f );
|
|
viewDistance = -196.f;
|
|
|
|
world = NULL;
|
|
worldModel = NULL;
|
|
|
|
ResetView();
|
|
}
|
|
|
|
idGLDrawableView::~idGLDrawableView() {
|
|
delete world;
|
|
delete worldModel;
|
|
}
|
|
|
|
void idGLDrawableView::ResetView( void ) {
|
|
idDict spawnArgs;
|
|
|
|
InitWorld();
|
|
|
|
memset( &worldEntity, 0, sizeof( worldEntity ) );
|
|
spawnArgs.Clear();
|
|
spawnArgs.Set("classname", "func_static");
|
|
spawnArgs.Set("name", spawnArgs.GetString("model"));
|
|
spawnArgs.Set("origin", "0 0 0");
|
|
|
|
gameEdit->ParseSpawnArgsToRenderEntity(&spawnArgs, &worldEntity);
|
|
|
|
// load a model and set the current material as its customshader
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/cube128.ase");
|
|
worldEntity.hModel = worldModel;
|
|
|
|
// current material
|
|
worldEntity.customShader = material;
|
|
|
|
// current rotation
|
|
worldEntity.axis = mat3_identity;
|
|
|
|
// set global shader parms
|
|
memset( globalParms, 0, sizeof( globalParms ) );
|
|
globalParms[0] = globalParms[1] = globalParms[2] = globalParms[3] = 1.f;
|
|
|
|
worldEntity.shaderParms[0] = 1.f;
|
|
worldEntity.shaderParms[1] = 1.f;
|
|
worldEntity.shaderParms[2] = 1.f;
|
|
worldEntity.shaderParms[3] = 1.f;
|
|
modelDefHandle = world->AddEntityDef( &worldEntity );
|
|
}
|
|
|
|
void idGLDrawableView::InitWorld() {
|
|
|
|
if ( world == NULL ) {
|
|
world = renderSystem->AllocRenderWorld();
|
|
}
|
|
if ( worldModel == NULL ) {
|
|
worldModel = renderModelManager->AllocModel();
|
|
}
|
|
|
|
world->InitFromMap( NULL );
|
|
worldModel->InitEmpty( "GLWorldModel" );
|
|
|
|
viewLights.Clear();
|
|
}
|
|
|
|
void idGLDrawableView::buttonDown(int _button, float x, float y) {
|
|
pressX = x;
|
|
pressY = y;
|
|
button = _button;
|
|
if ( button == MK_RBUTTON || button == MK_LBUTTON || button == MK_MBUTTON ) {
|
|
handleMove = true;
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::mouseMove(float x, float y) {
|
|
bool doZoom;
|
|
float sensitivity = 0.5f;
|
|
|
|
if (handleMove) {
|
|
|
|
// Left mouse button rotates and zooms the view
|
|
if (button == MK_LBUTTON) {
|
|
doZoom = Sys_KeyDown(VK_MENU);
|
|
if (doZoom) {
|
|
if ( y != pressY ) {
|
|
viewDistance -= ( y - pressY );
|
|
pressY = y;
|
|
}
|
|
} else {
|
|
float xo = 0.f;
|
|
float yo = 0.f;
|
|
|
|
if (x != pressX) {
|
|
xo = (x - pressX);
|
|
pressX = x;
|
|
}
|
|
if (y != pressY) {
|
|
yo = (y - pressY);
|
|
pressY = y;
|
|
}
|
|
|
|
viewRotation.yaw += -(xo * sensitivity);
|
|
viewRotation.pitch += (yo * sensitivity);
|
|
|
|
viewRotation.pitch = idMath::ClampFloat( -89.9f, 89.9f, viewRotation.pitch );
|
|
}
|
|
|
|
// Right mouse button moves lights in the view plane
|
|
} else if (button == MK_RBUTTON) {
|
|
int i;
|
|
float lightMovement = 0;
|
|
idVec3 lightForward, lightRight, lightUp;
|
|
idVec3 lightMove;
|
|
|
|
lightMove.Zero();
|
|
viewRotation.ToVectors( &lightForward, &lightRight, &lightUp );
|
|
|
|
doZoom = Sys_KeyDown(VK_MENU);
|
|
if (doZoom) {
|
|
if ( y != pressY ) {
|
|
lightMovement = -( y - pressY ) * sensitivity;
|
|
pressY = y;
|
|
|
|
lightMovement = idMath::ClampFloat( -32.f, 32.f, lightMovement );
|
|
lightMove = lightForward * lightMovement;
|
|
}
|
|
} else {
|
|
if (x != pressX) {
|
|
lightMovement = (x - pressX) * sensitivity;
|
|
pressX = x;
|
|
|
|
lightMovement = idMath::ClampFloat( -32.f, 32.f, lightMovement );
|
|
lightMove = lightRight * lightMovement;
|
|
}
|
|
if (y != pressY) {
|
|
lightMovement = -(y - pressY) * sensitivity;
|
|
pressY = y;
|
|
|
|
lightMovement = idMath::ClampFloat( -32.f, 32.f, lightMovement );
|
|
lightMove += lightUp * lightMovement;
|
|
}
|
|
}
|
|
|
|
// Go through the lights and move the ones that are set to allow movement
|
|
for ( i = 0; i < viewLights.Num(); i++ ) {
|
|
lightInfo_t *vLight = &viewLights[i];
|
|
|
|
if ( vLight->allowMove ) {
|
|
vLight->origin += lightMove;
|
|
}
|
|
}
|
|
|
|
// Middle mouse button moves object up and down
|
|
} else if ( button == MK_MBUTTON ) {
|
|
float yo = 0.f;
|
|
|
|
if (y != pressY) {
|
|
yo = (y - pressY);
|
|
pressY = y;
|
|
}
|
|
|
|
viewOrigin.z -= yo;
|
|
|
|
UpdateModel();
|
|
}
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::addLight( void ) {
|
|
int lightId;
|
|
idStr str;
|
|
lightInfo_t viewLight;
|
|
idDict spawnArgs;
|
|
|
|
lightId = viewLights.Num();
|
|
|
|
spawnArgs.Set( "classname", "light" );
|
|
spawnArgs.Set( "name", va( "light_%d", lightId ) );
|
|
spawnArgs.Set( "origin", va( "-128 0 %d", (lightId * 16) ) );
|
|
spawnArgs.Set( "light", "300" );
|
|
spawnArgs.Set( "texture", "lights/defaultPointLight" );
|
|
sprintf( str, "%f %f %f", 1.f, 1.f, 1.f );
|
|
spawnArgs.Set( "_color", str );
|
|
gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &viewLight.renderLight );
|
|
|
|
viewLight.lightDefHandle = world->AddLightDef( &viewLight.renderLight );
|
|
viewLight.origin = viewLight.renderLight.origin;
|
|
viewLight.shader = declManager->FindMaterial( "lights/defaultPointLight", false );
|
|
viewLight.color.x = viewLight.renderLight.shaderParms[ SHADERPARM_RED ];
|
|
viewLight.color.y = viewLight.renderLight.shaderParms[ SHADERPARM_GREEN ];
|
|
viewLight.color.z = viewLight.renderLight.shaderParms[ SHADERPARM_BLUE ];
|
|
viewLight.radius = 300.f;
|
|
viewLight.allowMove = true;
|
|
|
|
// Add light to the list
|
|
viewLights.Append( viewLight );
|
|
}
|
|
|
|
void idGLDrawableView::deleteLight( const int lightId ) {
|
|
if ( lightId < viewLights.Num() ) {
|
|
world->FreeLightDef( viewLights[lightId].lightDefHandle );
|
|
|
|
viewLights.RemoveIndex( lightId );
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::UpdateCamera( renderView_t *refdef ) {
|
|
idVec3 pos, dir;
|
|
idAngles angs;
|
|
|
|
// Set the camera origin
|
|
pos = viewRotation.ToForward();
|
|
pos *= viewDistance;
|
|
refdef->vieworg = pos;
|
|
|
|
// Set the view to point back at the origin
|
|
dir = vec3_origin - pos;
|
|
angs = dir.ToAngles();
|
|
refdef->viewaxis = angs.ToMat3();
|
|
}
|
|
|
|
|
|
void idGLDrawableView::UpdateModel( void ) {
|
|
|
|
switch( objectId ) {
|
|
case 0:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/cube128.ase");
|
|
break;
|
|
case 1:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/box128x64.ase");
|
|
break;
|
|
case 2:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/box128x32.ase");
|
|
break;
|
|
case 3:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/box64x128.ase");
|
|
break;
|
|
case 4:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/box32x128.ase");
|
|
break;
|
|
case 5:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/cylinder_v.ase");
|
|
break;
|
|
case 6:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/cylinder_h.ase");
|
|
break;
|
|
case 7:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/sphere64.ase");
|
|
break;
|
|
case -1:
|
|
worldModel = renderModelManager->FindModel( customModelName.c_str() );
|
|
break;
|
|
default:
|
|
worldModel = renderModelManager->FindModel("models/materialeditor/cube128.ase");
|
|
break;
|
|
};
|
|
|
|
worldEntity.hModel = worldModel;
|
|
|
|
// current material
|
|
worldEntity.customShader = material;
|
|
// current rotation
|
|
worldEntity.origin = viewOrigin;
|
|
|
|
worldEntity.axis = mat3_identity;
|
|
|
|
world->UpdateEntityDef( modelDefHandle, &worldEntity );
|
|
}
|
|
|
|
void idGLDrawableView::UpdateLights( void ) {
|
|
int i;
|
|
|
|
for ( i = 0; i < viewLights.Num(); i++ ) {
|
|
lightInfo_t *vLight = &viewLights[i];
|
|
|
|
vLight->renderLight.shader = vLight->shader;
|
|
|
|
vLight->renderLight.shaderParms[ SHADERPARM_RED ] = vLight->color.x;
|
|
vLight->renderLight.shaderParms[ SHADERPARM_GREEN ] = vLight->color.y;
|
|
vLight->renderLight.shaderParms[ SHADERPARM_BLUE ] = vLight->color.z;
|
|
|
|
vLight->renderLight.lightRadius[0] = vLight->renderLight.lightRadius[1] =
|
|
vLight->renderLight.lightRadius[2] = vLight->radius;
|
|
|
|
vLight->renderLight.origin = vLight->origin;
|
|
|
|
world->UpdateLightDef( vLight->lightDefHandle, &vLight->renderLight );
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::drawLights( renderView_t *refdef ) {
|
|
int i;
|
|
|
|
for ( i=0; i < viewLights.Num(); i++ ) {
|
|
lightInfo_t *vLight = &viewLights[i];
|
|
|
|
idVec4 lColor;
|
|
lColor.x = vLight->color.x;
|
|
lColor.y = vLight->color.y;
|
|
lColor.z = vLight->color.z;
|
|
lColor.w = 1.f;
|
|
|
|
idSphere sphere(vLight->renderLight.origin, 4);
|
|
session->rw->DebugSphere( lColor, sphere, 0, true );
|
|
session->rw->DrawText( va( "%d", i+1 ), vLight->renderLight.origin + idVec3(0,0,5), 0.25f, idVec4(1,1,0,1), refdef->viewaxis, 1, 0, true );
|
|
}
|
|
}
|
|
|
|
|
|
void idGLDrawableView::draw(int x, int y, int w, int h) {
|
|
int i;
|
|
renderView_t refdef;
|
|
const idMaterial *mat = material;
|
|
|
|
if (mat) {
|
|
qglViewport(x, y, w, h);
|
|
qglScissor(x, y, w, h);
|
|
qglMatrixMode(GL_PROJECTION);
|
|
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
|
|
qglClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
UpdateLights();
|
|
|
|
// render it
|
|
renderSystem->BeginFrame(w, h);
|
|
|
|
memset( &refdef, 0, sizeof( refdef ) );
|
|
|
|
UpdateCamera( &refdef );
|
|
|
|
// Copy global shaderparms to view
|
|
for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ ) {
|
|
refdef.shaderParms[ i ] = globalParms[ i ];
|
|
}
|
|
|
|
refdef.width = SCREEN_WIDTH;
|
|
refdef.height = SCREEN_HEIGHT;
|
|
refdef.fov_x = 90;
|
|
refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;
|
|
|
|
refdef.time = eventLoop->Milliseconds();
|
|
|
|
world->RenderScene( &refdef );
|
|
|
|
if ( showLights ) {
|
|
drawLights( &refdef );
|
|
}
|
|
|
|
renderSystem->EndFrame( NULL, NULL );
|
|
|
|
world->DebugClearLines( refdef.time );
|
|
|
|
qglMatrixMode( GL_MODELVIEW );
|
|
qglLoadIdentity();
|
|
}
|
|
}
|
|
|
|
// ============================
|
|
// Interface to PropTree Window
|
|
// ============================
|
|
|
|
void idGLDrawableView::setMedia(const char *name) {
|
|
float ratio = 1;
|
|
|
|
if (name && *name) {
|
|
material = declManager->FindMaterial(name);
|
|
} else {
|
|
material = NULL;
|
|
}
|
|
|
|
if ( material->GetNumStages() == 0 ) {
|
|
material = declManager->FindMaterial( "_default" );
|
|
}
|
|
|
|
if ( material->GetStage(0)->texture.image ) {
|
|
ratio = (float)((float)material->GetImageWidth() / (float)material->GetImageHeight());
|
|
}
|
|
|
|
if ( objectId == -1 ) {
|
|
// Don't change a custom model
|
|
} else if ( ratio == 1 ) {
|
|
objectId = 0;
|
|
} else if ( ratio == 2 ) {
|
|
objectId = 1;
|
|
} else if ( ratio == 4 ) {
|
|
objectId = 2;
|
|
} else if ( ratio == 0.5 ) {
|
|
objectId = 3;
|
|
} else if ( ratio == 0.25 ) {
|
|
objectId = 4;
|
|
}
|
|
|
|
UpdateModel();
|
|
}
|
|
|
|
void idGLDrawableView::setLocalParm( int parmNum, float value ) {
|
|
if ( parmNum < 0 || parmNum >= MAX_ENTITY_SHADER_PARMS ) {
|
|
return;
|
|
}
|
|
|
|
worldEntity.shaderParms[ parmNum ] = value;
|
|
|
|
UpdateModel();
|
|
}
|
|
|
|
void idGLDrawableView::setGlobalParm( int parmNum, float value ) {
|
|
if ( parmNum < 0 || parmNum >= MAX_GLOBAL_SHADER_PARMS ) {
|
|
return;
|
|
}
|
|
|
|
globalParms[ parmNum ] = value;
|
|
}
|
|
|
|
void idGLDrawableView::setLightShader( const int lightId, const idStr shaderName ) {
|
|
|
|
if ( lightId < viewLights.Num() ) {
|
|
viewLights[ lightId ].shader = declManager->FindMaterial( shaderName, false );
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::setLightColor( const int lightId, const idVec3 &value ) {
|
|
|
|
if ( lightId < viewLights.Num() ) {
|
|
// Update this lights color
|
|
viewLights[ lightId ].color = value;
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::setLightRadius( const int lightId, const float radius ) {
|
|
|
|
if ( lightId < viewLights.Num() ) {
|
|
viewLights[ lightId ].radius = radius;
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::setLightAllowMove( const int lightId, const bool move ) {
|
|
|
|
if ( lightId < viewLights.Num() ) {
|
|
viewLights[ lightId ].allowMove = move;
|
|
}
|
|
}
|
|
|
|
void idGLDrawableView::setObject( int Id ) {
|
|
objectId = Id;
|
|
|
|
UpdateModel();
|
|
}
|
|
|
|
void idGLDrawableView::setCustomModel( const idStr modelName ) {
|
|
|
|
if ( modelName.Length() ) {
|
|
objectId = -1;
|
|
} else {
|
|
objectId = 0;
|
|
}
|
|
|
|
customModelName = modelName;
|
|
|
|
UpdateModel();
|
|
}
|
|
|
|
void idGLDrawableView::setShowLights( bool _showLights ) {
|
|
showLights = _showLights;
|
|
}
|
|
|