mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-15 15:51:07 +02:00
Justin Marshall
2679 lines
71 KiB
C++
2679 lines
71 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 "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "qe3.h"
|
|
#include "Radiant.h"
|
|
#include "XYWnd.h"
|
|
#include "CamWnd.h"
|
|
#include "splines.h"
|
|
#include <GL/glu.h>
|
|
|
|
#include "../../renderer/tr_local.h"
|
|
#include "../../renderer/model_local.h" // for idRenderModelMD5
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
extern void DrawPathLines();
|
|
|
|
int g_axialAnchor = -1;
|
|
int g_axialDest = -1;
|
|
bool g_bAxialMode = false;
|
|
|
|
void ValidateAxialPoints() {
|
|
int faceCount = g_ptrSelectedFaces.GetSize();
|
|
if (faceCount > 0) {
|
|
face_t* selFace = reinterpret_cast <face_t*> (g_ptrSelectedFaces.GetAt(0));
|
|
if (g_axialAnchor >= selFace->face_winding->GetNumPoints()) {
|
|
g_axialAnchor = 0;
|
|
}
|
|
if (g_axialDest >= selFace->face_winding->GetNumPoints()) {
|
|
g_axialDest = 0;
|
|
}
|
|
}
|
|
else {
|
|
g_axialDest = 0;
|
|
g_axialAnchor = 0;
|
|
}
|
|
}
|
|
|
|
// CCamWnd
|
|
IMPLEMENT_DYNCREATE(CCamWnd, CWnd);
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
CCamWnd::CCamWnd() {
|
|
m_pXYFriend = NULL;
|
|
memset(&m_Camera, 0, sizeof(camera_t));
|
|
m_pSide_select = NULL;
|
|
m_bClipMode = false;
|
|
worldDirty = true;
|
|
worldModel = NULL;
|
|
worldModelDef = -1;
|
|
renderMode = false;
|
|
rebuildMode = false;
|
|
entityMode = false;
|
|
animationMode = false;
|
|
selectMode = false;
|
|
soundMode = false;
|
|
saveValid = false;
|
|
Cam_Init();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
CCamWnd::~CCamWnd() {
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CCamWnd, CWnd)
|
|
//{{AFX_MSG_MAP(CCamWnd)
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_PAINT()
|
|
ON_WM_DESTROY()
|
|
ON_WM_CLOSE()
|
|
ON_WM_MOUSEMOVE()
|
|
ON_WM_LBUTTONDOWN()
|
|
ON_WM_LBUTTONUP()
|
|
ON_WM_MBUTTONDOWN()
|
|
ON_WM_MBUTTONUP()
|
|
ON_WM_RBUTTONDOWN()
|
|
ON_WM_RBUTTONUP()
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_WM_KEYUP()
|
|
ON_WM_NCCALCSIZE()
|
|
ON_WM_KILLFOCUS()
|
|
ON_WM_SETFOCUS()
|
|
ON_WM_TIMER()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
INT_PTR WINAPI CamWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
RECT rect;
|
|
|
|
GetClientRect(hWnd, &rect);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_KILLFOCUS:
|
|
case WM_SETFOCUS:
|
|
SendMessage(hWnd, WM_NCACTIVATE, uMsg == WM_SETFOCUS, 0);
|
|
return 0;
|
|
|
|
case WM_NCCALCSIZE: // don't let windows copy pixels
|
|
DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
return WVR_REDRAW;
|
|
}
|
|
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// CCamWnd message handlers
|
|
// =======================================================================================================================
|
|
//
|
|
BOOL CCamWnd::PreCreateWindow(CREATESTRUCT& cs) {
|
|
WNDCLASS wc;
|
|
HINSTANCE hInstance = AfxGetInstanceHandle();
|
|
if (::GetClassInfo(hInstance, CAMERA_WINDOW_CLASS, &wc) == FALSE) {
|
|
// Register a new class
|
|
memset(&wc, 0, sizeof(wc));
|
|
|
|
// wc.style = CS_NOCLOSE | CS_OWNDC;
|
|
wc.style = CS_NOCLOSE;
|
|
wc.lpszClassName = CAMERA_WINDOW_CLASS;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.lpfnWndProc = CamWndProc;
|
|
if (AfxRegisterClass(&wc) == FALSE) {
|
|
Error("CCamWnd RegisterClass: failed");
|
|
}
|
|
}
|
|
|
|
cs.lpszClass = CAMERA_WINDOW_CLASS;
|
|
cs.lpszName = "CAM";
|
|
if (cs.style != QE3_CHILDSTYLE) {
|
|
cs.style = QE3_SPLITTER_STYLE;
|
|
}
|
|
|
|
BOOL bResult = CWnd::PreCreateWindow(cs);
|
|
|
|
//
|
|
// See if the class already exists and if not then we need to register our new
|
|
// window class.
|
|
//
|
|
return bResult;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) {
|
|
g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags);
|
|
}
|
|
|
|
brush_t* g_pSplitList = NULL;
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnPaint() {
|
|
CPaintDC dc(this); // device context for painting
|
|
bool bPaint = true;
|
|
|
|
UpdateCaption();
|
|
|
|
idGraphicsDeviceContextHelper context(dc.m_hDC, hglrc);
|
|
|
|
g_pSplitList = NULL;
|
|
if (g_bClipMode) {
|
|
if (g_Clip1.Set() && g_Clip2.Set()) {
|
|
g_pSplitList = ((g_pParentWnd->ActiveXY()->GetViewType() == XZ) ? !g_bSwitch : g_bSwitch) ? &g_brBackSplits : &g_brFrontSplits;
|
|
}
|
|
}
|
|
|
|
Cam_Draw();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::SetXYFriend(CXYWnd* pWnd) {
|
|
m_pXYFriend = pWnd;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnDestroy() {
|
|
CWnd::OnDestroy();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnClose() {
|
|
CWnd::OnClose();
|
|
}
|
|
|
|
extern void Select_RotateTexture(float amt, bool absolute);
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnMouseMove(UINT nFlags, CPoint point) {
|
|
CRect r;
|
|
GetClientRect(r);
|
|
if (GetCapture() == this && (GetAsyncKeyState(VK_MENU) & 0x8000) && !((GetAsyncKeyState(VK_SHIFT) & 0x8000) || (GetAsyncKeyState(VK_CONTROL) & 0x8000))) {
|
|
if (GetAsyncKeyState(VK_CONTROL) & 0x8000) {
|
|
Select_RotateTexture((float)point.y - m_ptLastCursor.y);
|
|
}
|
|
else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) {
|
|
Select_ScaleTexture((float)point.x - m_ptLastCursor.x, (float)m_ptLastCursor.y - point.y);
|
|
}
|
|
else {
|
|
Select_ShiftTexture((float)point.x - m_ptLastCursor.x, (float)m_ptLastCursor.y - point.y);
|
|
}
|
|
}
|
|
else {
|
|
Cam_MouseMoved(point.x, r.bottom - 1 - point.y, nFlags);
|
|
}
|
|
|
|
m_ptLastCursor = point;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnLButtonDown(UINT nFlags, CPoint point) {
|
|
m_ptLastCursor = point;
|
|
OriginalMouseDown(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnLButtonUp(UINT nFlags, CPoint point) {
|
|
OriginalMouseUp(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnMButtonDown(UINT nFlags, CPoint point) {
|
|
OriginalMouseDown(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnMButtonUp(UINT nFlags, CPoint point) {
|
|
OriginalMouseUp(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnRButtonDown(UINT nFlags, CPoint point) {
|
|
OriginalMouseDown(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnRButtonUp(UINT nFlags, CPoint point) {
|
|
OriginalMouseUp(nFlags, point);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
int CCamWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) {
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
CDC* pDC = GetDC();
|
|
HDC hDC = pDC->GetSafeHdc();
|
|
|
|
QEW_SetupPixelFormat(hDC, true);
|
|
|
|
HFONT hfont = CreateFont(
|
|
12, // logical height of font
|
|
0, // logical average character width
|
|
0, // angle of escapement
|
|
0, // base-line orientation angle
|
|
0, // font weight
|
|
0, // italic attribute flag
|
|
0, // underline attribute flag
|
|
0, // strikeout attribute flag
|
|
0, // character set identifier
|
|
0, // output precision
|
|
0, // clipping precision
|
|
0, // output quality
|
|
FIXED_PITCH | FF_MODERN, // pitch and family
|
|
"Lucida Console" // pointer to typeface name string
|
|
);
|
|
|
|
if (!hfont) {
|
|
Error("couldn't create font");
|
|
}
|
|
|
|
HFONT hOldFont = (HFONT)SelectObject(hDC, hfont);
|
|
|
|
if ((hglrc = (HGLRC)wglCreateContext(hDC)) == 0)
|
|
Error("wglCreateContext failed");
|
|
|
|
wglMakeCurrent(hDC, hglrc);
|
|
|
|
if ((g_qeglobals.d_font_list = glGenLists(256)) == 0) {
|
|
common->Warning("couldn't create font dlists");
|
|
}
|
|
|
|
// create the bitmap display lists we're making images of glyphs 0 thru 255
|
|
if (!wglUseFontBitmaps(hDC, 0, 255, g_qeglobals.d_font_list)) {
|
|
common->Warning("wglUseFontBitmaps failed (%d). Trying again.", GetLastError());
|
|
|
|
// FIXME: This is really wacky, sometimes the first call fails, but calling it again makes it work
|
|
// This probably indicates there's something wrong somewhere else in the code, but I'm not sure what
|
|
if (!wglUseFontBitmaps(hDC, 0, 255, g_qeglobals.d_font_list)) {
|
|
common->Warning("wglUseFontBitmaps failed again (%d). Trying outlines.", GetLastError());
|
|
|
|
// if (!wglUseFontOutlines(hDC, 0, 255, g_qeglobals.d_font_list, 0.0f, 0.1f, WGL_FONT_LINES, NULL)) {
|
|
// common->Warning( "wglUseFontOutlines also failed (%d), no coordinate text will be visible.", GetLastError() );
|
|
// }
|
|
}
|
|
}
|
|
|
|
SelectObject(hDC, hOldFont);
|
|
ReleaseDC(pDC);
|
|
|
|
// indicate start of glyph display lists
|
|
glListBase(g_qeglobals.d_font_list);
|
|
|
|
// report OpenGL information
|
|
common->Printf("GL_VENDOR: %s\n", glGetString(GL_VENDOR));
|
|
common->Printf("GL_RENDERER: %s\n", glGetString(GL_RENDERER));
|
|
common->Printf("GL_VERSION: %s\n", glGetString(GL_VERSION));
|
|
common->Printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OriginalMouseUp(UINT nFlags, CPoint point) {
|
|
CRect r;
|
|
GetClientRect(r);
|
|
Cam_MouseUp(point.x, r.bottom - 1 - point.y, nFlags);
|
|
if (!(nFlags & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON))) {
|
|
ReleaseCapture();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OriginalMouseDown(UINT nFlags, CPoint point) {
|
|
// if (GetTopWindow()->GetSafeHwnd() != GetSafeHwnd()) BringWindowToTop();
|
|
CRect r;
|
|
GetClientRect(r);
|
|
SetFocus();
|
|
SetCapture();
|
|
|
|
// if (!(GetAsyncKeyState(VK_MENU) & 0x8000))
|
|
Cam_MouseDown(point.x, r.bottom - 1 - point.y, nFlags);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_Init() {
|
|
// m_Camera.draw_mode = cd_texture;
|
|
m_Camera.origin[0] = 0.0f;
|
|
m_Camera.origin[1] = 20.0f;
|
|
m_Camera.origin[2] = 72.0f;
|
|
m_Camera.color[0] = 0.3f;
|
|
m_Camera.color[1] = 0.3f;
|
|
m_Camera.color[2] = 0.3f;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_BuildMatrix() {
|
|
float xa, ya;
|
|
float matrix[4][4];
|
|
int i;
|
|
|
|
xa = ((renderMode) ? -m_Camera.angles[PITCH] : m_Camera.angles[PITCH]) * idMath::M_DEG2RAD;
|
|
ya = m_Camera.angles[YAW] * idMath::M_DEG2RAD;
|
|
|
|
// the movement matrix is kept 2d
|
|
m_Camera.forward[0] = cos(ya);
|
|
m_Camera.forward[1] = sin(ya);
|
|
m_Camera.right[0] = m_Camera.forward[1];
|
|
m_Camera.right[1] = -m_Camera.forward[0];
|
|
|
|
glGetFloatv(GL_PROJECTION_MATRIX, &matrix[0][0]);
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
m_Camera.vright[i] = matrix[i][0];
|
|
m_Camera.vup[i] = matrix[i][1];
|
|
m_Camera.vpn[i] = matrix[i][2];
|
|
}
|
|
|
|
m_Camera.vright.Normalize();
|
|
m_Camera.vup.Normalize();
|
|
m_Camera.vpn.Normalize();
|
|
InitCull();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
|
|
void CCamWnd::Cam_ChangeFloor(bool up) {
|
|
brush_t* b;
|
|
float d, bestd, current;
|
|
idVec3 start, dir;
|
|
|
|
start[0] = m_Camera.origin[0];
|
|
start[1] = m_Camera.origin[1];
|
|
start[2] = HUGE_DISTANCE;
|
|
dir[0] = dir[1] = 0;
|
|
dir[2] = -1;
|
|
|
|
current = HUGE_DISTANCE - (m_Camera.origin[2] - 72);
|
|
if (up) {
|
|
bestd = 0;
|
|
}
|
|
else {
|
|
bestd = HUGE_DISTANCE * 2;
|
|
}
|
|
|
|
for (b = active_brushes.next; b != &active_brushes; b = b->next) {
|
|
if (!Brush_Ray(start, dir, b, &d)) {
|
|
continue;
|
|
}
|
|
|
|
if (up && d < current && d > bestd) {
|
|
bestd = d;
|
|
}
|
|
|
|
if (!up && d > current && d < bestd) {
|
|
bestd = d;
|
|
}
|
|
}
|
|
|
|
if (bestd == 0 || bestd == HUGE_DISTANCE * 2) {
|
|
return;
|
|
}
|
|
|
|
m_Camera.origin[2] += current - bestd;
|
|
Sys_UpdateWindows(W_CAMERA | W_Z_OVERLAY);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_PositionDrag() {
|
|
int x, y;
|
|
Sys_GetCursorPos(&x, &y);
|
|
if (x != m_ptCursor.x || y != m_ptCursor.y) {
|
|
x -= m_ptCursor.x;
|
|
VectorMA(m_Camera.origin, x, m_Camera.vright, m_Camera.origin);
|
|
y -= m_ptCursor.y;
|
|
m_Camera.origin[2] -= y;
|
|
SetCursorPos(m_ptCursor.x, m_ptCursor.y);
|
|
Sys_UpdateWindows(W_CAMERA | W_XY_OVERLAY);
|
|
}
|
|
}
|
|
|
|
void CCamWnd::Cam_MouseLook() {
|
|
CPoint current;
|
|
|
|
GetCursorPos(¤t);
|
|
if (current.x != m_ptCursor.x || current.y != m_ptCursor.y) {
|
|
|
|
current.x -= m_ptCursor.x;
|
|
current.y -= m_ptCursor.y;
|
|
|
|
m_Camera.angles[PITCH] -= (float)((float)current.y * 0.25f);
|
|
m_Camera.angles[YAW] -= (float)((float)current.x * 0.25f);
|
|
|
|
SetCursorPos(m_ptCursor.x, m_ptCursor.y);
|
|
|
|
Cam_BuildMatrix();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_MouseControl(float dtime) {
|
|
int xl, xh;
|
|
int yl, yh;
|
|
float xf, yf;
|
|
if (g_PrefsDlg.m_nMouseButtons == 2) {
|
|
if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT)) {
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
if (m_nCambuttonstate != MK_RBUTTON) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
xf = (float)(m_ptButton.x - m_Camera.width / 2) / (m_Camera.width / 2);
|
|
yf = (float)(m_ptButton.y - m_Camera.height / 2) / (m_Camera.height / 2);
|
|
|
|
xl = m_Camera.width / 3;
|
|
xh = xl * 2;
|
|
yl = m_Camera.height / 3;
|
|
yh = yl * 2;
|
|
|
|
// common->Printf("xf-%f yf-%f xl-%i xh-i% yl-i% yh-i%\n",xf,yf,xl,xh,yl,yh);
|
|
#if 0
|
|
|
|
// strafe
|
|
if (buttony < yl && (buttonx < xl || buttonx > xh)) {
|
|
VectorMA(camera.origin, xf * dtime * g_nMoveSpeed, camera.right, camera.origin);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
xf *= 1.0f - idMath::Fabs(yf);
|
|
if (xf < 0.0f) {
|
|
xf += 0.1f;
|
|
if (xf > 0.0f) {
|
|
xf = 0.0f;
|
|
}
|
|
}
|
|
else {
|
|
xf -= 0.1f;
|
|
if (xf < 0.0f) {
|
|
xf = 0.0f;
|
|
}
|
|
}
|
|
|
|
VectorMA(m_Camera.origin, yf * dtime * g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
|
|
m_Camera.angles[YAW] += xf * -dtime * g_PrefsDlg.m_nAngleSpeed;
|
|
}
|
|
|
|
Cam_BuildMatrix();
|
|
int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
|
|
Sys_UpdateWindows(nUpdate);
|
|
g_pParentWnd->PostMessage(WM_TIMER, 0, 0);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_MouseDown(int x, int y, int buttons) {
|
|
idVec3 dir;
|
|
float f, r, u;
|
|
int i;
|
|
|
|
// calc ray direction
|
|
u = (float)(y - m_Camera.height / 2) / (m_Camera.width / 2);
|
|
r = (float)(x - m_Camera.width / 2) / (m_Camera.width / 2);
|
|
f = 1;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
|
|
}
|
|
|
|
dir.Normalize();
|
|
|
|
GetCursorPos(&m_ptCursor);
|
|
|
|
m_nCambuttonstate = buttons;
|
|
m_ptButton.x = x;
|
|
m_ptButton.y = y;
|
|
|
|
//
|
|
// LBUTTON = manipulate selection shift-LBUTTON = select middle button = grab
|
|
// texture ctrl-middle button = set entire brush to texture ctrl-shift-middle
|
|
// button = set single face to texture
|
|
//
|
|
int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
|
|
if
|
|
(
|
|
(buttons == MK_LBUTTON) ||
|
|
(buttons == (MK_LBUTTON | MK_SHIFT)) ||
|
|
(buttons == (MK_LBUTTON | MK_CONTROL)) ||
|
|
(buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT)) ||
|
|
(buttons == nMouseButton) ||
|
|
(buttons == (nMouseButton | MK_SHIFT)) ||
|
|
(buttons == (nMouseButton | MK_CONTROL)) ||
|
|
(buttons == (nMouseButton | MK_SHIFT | MK_CONTROL))
|
|
) {
|
|
if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT))) {
|
|
Cam_MouseControl(0.1f);
|
|
}
|
|
else {
|
|
// something global needs to track which window is responsible for stuff
|
|
Patch_SetView(W_CAMERA);
|
|
Drag_Begin(x, y, buttons, m_Camera.vright, m_Camera.vup, m_Camera.origin, dir);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (buttons == MK_RBUTTON) {
|
|
Cam_MouseControl(0.1f);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_MouseUp(int x, int y, int buttons) {
|
|
m_nCambuttonstate = 0;
|
|
Drag_MouseUp(buttons);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_MouseMoved(int x, int y, int buttons) {
|
|
m_nCambuttonstate = buttons;
|
|
if (!buttons) {
|
|
return;
|
|
}
|
|
|
|
m_ptButton.x = x;
|
|
m_ptButton.y = y;
|
|
|
|
if (buttons == (MK_RBUTTON | MK_CONTROL)) {
|
|
Cam_PositionDrag();
|
|
Sys_UpdateWindows(W_XY | W_CAMERA | W_Z);
|
|
return;
|
|
}
|
|
else if (buttons == (MK_RBUTTON | MK_CONTROL | MK_SHIFT)) {
|
|
Cam_MouseLook();
|
|
Sys_UpdateWindows(W_XY | W_CAMERA | W_Z);
|
|
return;
|
|
}
|
|
|
|
GetCursorPos(&m_ptCursor);
|
|
|
|
if (buttons & (MK_LBUTTON | MK_MBUTTON)) {
|
|
Drag_MouseMoved(x, y, buttons);
|
|
Sys_UpdateWindows(W_XY | W_CAMERA | W_Z);
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::InitCull() {
|
|
int i;
|
|
|
|
VectorSubtract(m_Camera.vpn, m_Camera.vright, m_vCull1);
|
|
VectorAdd(m_Camera.vpn, m_Camera.vright, m_vCull2);
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
if (m_vCull1[i] > 0) {
|
|
m_nCullv1[i] = 3 + i;
|
|
}
|
|
else {
|
|
m_nCullv1[i] = i;
|
|
}
|
|
|
|
if (m_vCull2[i] > 0) {
|
|
m_nCullv2[i] = 3 + i;
|
|
}
|
|
else {
|
|
m_nCullv2[i] = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
bool CCamWnd::CullBrush(brush_t* b, bool cubicOnly) {
|
|
int i;
|
|
idVec3 point;
|
|
float d;
|
|
|
|
if (b->forceVisibile) {
|
|
return false;
|
|
}
|
|
|
|
if (g_PrefsDlg.m_bCubicClipping) {
|
|
|
|
float distance = g_PrefsDlg.m_nCubicScale * 64;
|
|
|
|
idVec3 mid;
|
|
for (int i = 0; i < 3; i++) {
|
|
mid[i] = (b->mins[i] + ((b->maxs[i] - b->mins[i]) / 2));
|
|
}
|
|
|
|
point = mid - m_Camera.origin;
|
|
if (point.Length() > distance) {
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
if (cubicOnly) {
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];
|
|
}
|
|
|
|
d = DotProduct(point, m_vCull1);
|
|
if (d < -1) {
|
|
return true;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];
|
|
}
|
|
|
|
d = DotProduct(point, m_vCull2);
|
|
if (d < -1) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#if 0
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::DrawLightRadius(brush_t* pBrush) {
|
|
// if lighting
|
|
int nRadius = Brush_LightRadius(pBrush);
|
|
if (nRadius > 0) {
|
|
Brush_SetLightColor(pBrush);
|
|
glEnable(GL_BLEND);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glDisable(GL_BLEND);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void setGLMode(int mode) {
|
|
switch (mode)
|
|
{
|
|
case cd_wire:
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
globalImages->BindNull();
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
break;
|
|
|
|
case cd_solid:
|
|
glCullFace(GL_FRONT);
|
|
glEnable(GL_CULL_FACE);
|
|
glShadeModel(GL_FLAT);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
globalImages->BindNull();
|
|
glDisable(GL_BLEND);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthFunc(GL_LEQUAL);
|
|
break;
|
|
|
|
case cd_texture:
|
|
glCullFace(GL_FRONT);
|
|
glEnable(GL_CULL_FACE);
|
|
glShadeModel(GL_FLAT);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glDisable(GL_BLEND);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthFunc(GL_LEQUAL);
|
|
break;
|
|
|
|
case cd_blend:
|
|
glCullFace(GL_FRONT);
|
|
glEnable(GL_CULL_FACE);
|
|
glShadeModel(GL_FLAT);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
extern void glLabeledPoint(idVec4& color, idVec3& point, float size, const char* label);
|
|
void DrawAxial(face_t* selFace) {
|
|
if (g_bAxialMode) {
|
|
idVec3 points[4];
|
|
|
|
for (int j = 0; j < selFace->face_winding->GetNumPoints(); j++) {
|
|
glLabeledPoint(idVec4(1, 1, 1, 1), (*selFace->face_winding)[j].ToVec3(), 3, va("%i", j));
|
|
}
|
|
|
|
ValidateAxialPoints();
|
|
points[0] = (*selFace->face_winding)[g_axialAnchor].ToVec3();
|
|
VectorMA(points[0], 1, selFace->plane, points[0]);
|
|
VectorMA(points[0], 4, selFace->plane, points[1]);
|
|
points[3] = (*selFace->face_winding)[g_axialDest].ToVec3();
|
|
VectorMA(points[3], 1, selFace->plane, points[3]);
|
|
VectorMA(points[3], 4, selFace->plane, points[2]);
|
|
glLabeledPoint(idVec4(1, 0, 0, 1), points[1], 3, "Anchor");
|
|
glLabeledPoint(idVec4(1, 1, 0, 1), points[2], 3, "Dest");
|
|
glBegin(GL_LINE_STRIP);
|
|
glVertex3fv(points[0].ToFloatPtr());
|
|
glVertex3fv(points[1].ToFloatPtr());
|
|
glVertex3fv(points[2].ToFloatPtr());
|
|
glVertex3fv(points[3].ToFloatPtr());
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Cam_Draw
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::SetProjectionMatrix() {
|
|
float xfov = 90;
|
|
float yfov = 2 * atan((float)m_Camera.height / m_Camera.width) * idMath::M_RAD2DEG;
|
|
#if 0
|
|
float screenaspect = (float)m_Camera.width / m_Camera.height;
|
|
glLoadIdentity();
|
|
gluPerspective(yfov, screenaspect, 2, 8192);
|
|
#else
|
|
float xmin, xmax, ymin, ymax;
|
|
float width, height;
|
|
float zNear;
|
|
float projectionMatrix[16];
|
|
|
|
//
|
|
// set up projection matrix
|
|
//
|
|
zNear = r_znear.GetFloat();
|
|
|
|
ymax = zNear * tan(yfov * idMath::PI / 360.0f);
|
|
ymin = -ymax;
|
|
|
|
xmax = zNear * tan(xfov * idMath::PI / 360.0f);
|
|
xmin = -xmax;
|
|
|
|
width = xmax - xmin;
|
|
height = ymax - ymin;
|
|
|
|
projectionMatrix[0] = 2 * zNear / width;
|
|
projectionMatrix[4] = 0;
|
|
projectionMatrix[8] = (xmax + xmin) / width; // normally 0
|
|
projectionMatrix[12] = 0;
|
|
|
|
projectionMatrix[1] = 0;
|
|
projectionMatrix[5] = 2 * zNear / height;
|
|
projectionMatrix[9] = (ymax + ymin) / height; // normally 0
|
|
projectionMatrix[13] = 0;
|
|
|
|
// this is the far-plane-at-infinity formulation
|
|
projectionMatrix[2] = 0;
|
|
projectionMatrix[6] = 0;
|
|
projectionMatrix[10] = -1;
|
|
projectionMatrix[14] = -2 * zNear;
|
|
|
|
projectionMatrix[3] = 0;
|
|
projectionMatrix[7] = 0;
|
|
projectionMatrix[11] = -1;
|
|
projectionMatrix[15] = 0;
|
|
|
|
glLoadMatrixf(projectionMatrix);
|
|
#endif
|
|
}
|
|
|
|
void CCamWnd::Cam_Draw() {
|
|
brush_t* brush;
|
|
face_t* face;
|
|
|
|
// float yfov;
|
|
int i;
|
|
|
|
if (!active_brushes.next) {
|
|
return; // not valid yet
|
|
}
|
|
|
|
// set the sound origin for both simple draw and rendered mode
|
|
// the editor uses opposite pitch convention
|
|
idMat3 axis = idAngles(-m_Camera.angles.pitch, m_Camera.angles.yaw, m_Camera.angles.roll).ToMat3();
|
|
g_qeglobals.sw->PlaceListener(m_Camera.origin, axis, 0, Sys_Milliseconds(), "Undefined");
|
|
|
|
if (renderMode) {
|
|
Cam_Render();
|
|
}
|
|
|
|
|
|
glViewport(0, 0, m_Camera.width, m_Camera.height);
|
|
glScissor(0, 0, m_Camera.width, m_Camera.height);
|
|
glClearColor(g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0], g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1], g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
|
|
|
|
if (!renderMode) {
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
glDisable(GL_LIGHTING);
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
SetProjectionMatrix();
|
|
|
|
glRotatef(-90, 1, 0, 0); // put Z going up
|
|
glRotatef(90, 0, 0, 1); // put Z going up
|
|
glRotatef(m_Camera.angles[0], 0, 1, 0);
|
|
glRotatef(-m_Camera.angles[1], 0, 0, 1);
|
|
glTranslatef(-m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
|
|
|
|
Cam_BuildMatrix();
|
|
|
|
for (brush = active_brushes.next; brush != &active_brushes; brush = brush->next) {
|
|
|
|
if (CullBrush(brush, false)) {
|
|
continue;
|
|
}
|
|
|
|
if (FilterBrush(brush)) {
|
|
continue;
|
|
}
|
|
|
|
if (renderMode) {
|
|
if (!(entityMode && brush->owner->eclass->fixedsize)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
setGLMode(m_Camera.draw_mode);
|
|
Brush_Draw(brush);
|
|
}
|
|
|
|
|
|
//glDepthMask ( 1 ); // Ok, write now
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
glTranslatef(g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]);
|
|
|
|
brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
|
|
|
|
if (!renderMode) {
|
|
// draw normally
|
|
for (brush = pList->next; brush != pList; brush = brush->next) {
|
|
if (brush->pPatch) {
|
|
continue;
|
|
}
|
|
setGLMode(m_Camera.draw_mode);
|
|
Brush_Draw(brush, true);
|
|
}
|
|
}
|
|
|
|
// blend on top
|
|
|
|
setGLMode(m_Camera.draw_mode);
|
|
glDisable(GL_LIGHTING);
|
|
glColor4f(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][0], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][1], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][2], 0.25f);
|
|
glEnable(GL_BLEND);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
globalImages->BindNull();
|
|
for (brush = pList->next; brush != pList; brush = brush->next) {
|
|
if (brush->pPatch || brush->modelHandle > 0) {
|
|
Brush_Draw(brush, true);
|
|
|
|
// DHM - Nerve:: patch display lists/models mess with the state
|
|
glEnable(GL_BLEND);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glColor4f(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][0], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][1], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][2], 0.25f);
|
|
globalImages->BindNull();
|
|
continue;
|
|
}
|
|
|
|
if (brush->owner->eclass->entityModel) {
|
|
continue;
|
|
}
|
|
|
|
for (face = brush->brush_faces; face; face = face->next) {
|
|
Face_Draw(face);
|
|
}
|
|
}
|
|
|
|
int nCount = g_ptrSelectedFaces.GetSize();
|
|
|
|
if (!renderMode) {
|
|
for (int i = 0; i < nCount; i++) {
|
|
face_t* selFace = reinterpret_cast <face_t*>(g_ptrSelectedFaces.GetAt(i));
|
|
Face_Draw(selFace);
|
|
DrawAxial(selFace);
|
|
}
|
|
}
|
|
|
|
// non-zbuffered outline
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
|
|
if (renderMode) {
|
|
glColor3f(1, 0, 0);
|
|
for (int i = 0; i < nCount; i++) {
|
|
face_t* selFace = reinterpret_cast <face_t*>(g_ptrSelectedFaces.GetAt(i));
|
|
Face_Draw(selFace);
|
|
}
|
|
}
|
|
|
|
glColor3f(1, 1, 1);
|
|
for (brush = pList->next; brush != pList; brush = brush->next) {
|
|
if (brush->pPatch || brush->modelHandle > 0) {
|
|
continue;
|
|
}
|
|
|
|
for (face = brush->brush_faces; face; face = face->next) {
|
|
Face_Draw(face);
|
|
}
|
|
}
|
|
// edge / vertex flags
|
|
if (g_qeglobals.d_select_mode == sel_vertex) {
|
|
glPointSize(4);
|
|
glColor3f(0, 1, 0);
|
|
glBegin(GL_POINTS);
|
|
for (i = 0; i < g_qeglobals.d_numpoints; i++) {
|
|
glVertex3fv(g_qeglobals.d_points[i].ToFloatPtr());
|
|
}
|
|
|
|
glEnd();
|
|
glPointSize(1);
|
|
}
|
|
else if (g_qeglobals.d_select_mode == sel_edge) {
|
|
float* v1, * v2;
|
|
|
|
glPointSize(4);
|
|
glColor3f(0, 0, 1);
|
|
glBegin(GL_POINTS);
|
|
for (i = 0; i < g_qeglobals.d_numedges; i++) {
|
|
v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1].ToFloatPtr();
|
|
v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2].ToFloatPtr();
|
|
glVertex3f((v1[0] + v2[0]) * 0.5f, (v1[1] + v2[1]) * 0.5f, (v1[2] + v2[2]) * 0.5f);
|
|
}
|
|
|
|
glEnd();
|
|
glPointSize(1);
|
|
}
|
|
|
|
g_splineList->draw(static_cast<bool>(g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint));
|
|
|
|
if (g_qeglobals.selectObject && (g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)) {
|
|
g_qeglobals.selectObject->drawSelection();
|
|
}
|
|
|
|
// draw pointfile
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
DrawPathLines();
|
|
|
|
if (g_qeglobals.d_pointfile_display_list) {
|
|
Pointfile_Draw();
|
|
}
|
|
|
|
//
|
|
// bind back to the default texture so that we don't have problems elsewhere
|
|
// using/modifying texture maps between contexts
|
|
//
|
|
globalImages->BindNull();
|
|
|
|
glFinish();
|
|
QE_CheckOpenGLForErrors();
|
|
|
|
if (!renderMode) {
|
|
// clean up any deffered tri's
|
|
R_ToggleSmpFrame();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnSize(UINT nType, int cx, int cy) {
|
|
CWnd::OnSize(nType, cx, cy);
|
|
|
|
CRect rect;
|
|
GetClientRect(rect);
|
|
m_Camera.width = rect.right;
|
|
m_Camera.height = rect.bottom;
|
|
InvalidateRect(NULL, false);
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) {
|
|
g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags, false);
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// Timo brush primitive texture shifting, using camera view to select translations::
|
|
// =======================================================================================================================
|
|
//
|
|
void CCamWnd::ShiftTexture_BrushPrimit(face_t* f, int x, int y) {
|
|
/*
|
|
idVec3 texS, texT;
|
|
idVec3 viewX, viewY;
|
|
int XS, XT, YS, YT;
|
|
int outS, outT;
|
|
#ifdef _DEBUG
|
|
if (!g_qeglobals.m_bBrushPrimitMode) {
|
|
common->Printf("Warning : unexpected call to CCamWnd::ShiftTexture_BrushPrimit with brush primitive mode disbaled\n");
|
|
return;
|
|
}
|
|
#endif
|
|
// compute face axis base
|
|
//ComputeAxisBase(f->plane.Normal(), texS, texT);
|
|
|
|
// compute camera view vectors
|
|
VectorCopy(m_Camera.vup, viewY);
|
|
VectorCopy(m_Camera.vright, viewX);
|
|
|
|
// compute best vectors
|
|
//ComputeBest2DVector(viewX, texS, texT, XS, XT);
|
|
//ComputeBest2DVector(viewY, texS, texT, YS, YT);
|
|
|
|
// check this is not a degenerate case
|
|
if ((XS == YS) && (XT == YT))
|
|
{
|
|
#ifdef _DEBUG
|
|
common->Printf("Warning : degenerate best vectors axis base in CCamWnd::ShiftTexture_BrushPrimit\n");
|
|
#endif
|
|
// forget it
|
|
Select_ShiftTexture_BrushPrimit(f, x, y, false);
|
|
return;
|
|
}
|
|
|
|
// compute best fitted translation in face axis base
|
|
outS = XS * x + YS * y;
|
|
outT = XT * x + YT * y;
|
|
|
|
// call actual texture shifting code
|
|
Select_ShiftTexture_BrushPrimit(f, outS, outT, false);
|
|
*/
|
|
}
|
|
|
|
|
|
bool IsBModel(brush_t* b) {
|
|
const char* v = ValueForKey(b->owner, "model");
|
|
if (v && *v) {
|
|
const char* n = ValueForKey(b->owner, "name");
|
|
return (stricmp(n, v) == 0);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
BuildEntityRenderState
|
|
|
|
Creates or updates modelDef and lightDef for an entity
|
|
================
|
|
*/
|
|
int Brush_ToTris(brush_t* brush, idTriList* tris, idMatList* mats, bool models, bool bmodel);
|
|
|
|
|
|
/*
|
|
================
|
|
Incremental editor render state
|
|
|
|
The old editor render path rebuilt one giant EditorWorldModel and reinitialized
|
|
the renderWorld whenever worldDirty was set. That is especially expensive for
|
|
ray traced backends because every edit invalidates the entire acceleration
|
|
structure. The editor now keeps one render entity/model per world brush and
|
|
small caches for editor entities. BuildRendererState() is therefore a
|
|
reconcile pass:
|
|
- add render defs for new brushes/entities,
|
|
- update only transforms for moved brushes,
|
|
- rebuild only the model whose geometry/material hash changed,
|
|
- free only defs/models that disappeared or became filtered.
|
|
================
|
|
*/
|
|
|
|
#define EDITOR_RENDER_HASH_INIT 2166136261u
|
|
#define EDITOR_RENDER_HASH_MUL 16777619u
|
|
|
|
struct editorRenderWorldBrushState_t {
|
|
brush_t* brush;
|
|
idRenderModel* model;
|
|
int modelDef;
|
|
unsigned int geometryHash;
|
|
idVec3 origin;
|
|
bool touched;
|
|
};
|
|
|
|
struct editorRenderEntityState_t {
|
|
entity_t* ent;
|
|
int modelDef;
|
|
int lightDef;
|
|
bool touched;
|
|
};
|
|
|
|
struct editorRenderBModelState_t {
|
|
entity_t* ent;
|
|
idRenderModel* model;
|
|
idStr modelName;
|
|
unsigned int geometryHash;
|
|
bool touched;
|
|
};
|
|
|
|
static bool s_editorRenderWorldInitialized = false;
|
|
static idList<editorRenderWorldBrushState_t> s_editorWorldBrushStates;
|
|
static idList<editorRenderEntityState_t> s_editorEntityStates;
|
|
static idList<editorRenderBModelState_t> s_editorBModelStates;
|
|
|
|
static unsigned int EditorHashBytes(unsigned int hash, const void* data, int numBytes) {
|
|
const unsigned char* bytes = reinterpret_cast<const unsigned char*>(data);
|
|
for (int i = 0; i < numBytes; i++) {
|
|
hash ^= bytes[i];
|
|
hash *= EDITOR_RENDER_HASH_MUL;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
static unsigned int EditorHashInt(unsigned int hash, int value) {
|
|
return EditorHashBytes(hash, &value, sizeof(value));
|
|
}
|
|
|
|
static int EditorQuantizeFloatForHash(float value) {
|
|
const float scale = 10000.0f;
|
|
return (int)(value * scale + (value >= 0.0f ? 0.5f : -0.5f));
|
|
}
|
|
|
|
static unsigned int EditorHashFloat(unsigned int hash, float value) {
|
|
const int quantized = EditorQuantizeFloatForHash(value);
|
|
return EditorHashInt(hash, quantized);
|
|
}
|
|
|
|
static unsigned int EditorHashString(unsigned int hash, const char* value) {
|
|
if (value == NULL) {
|
|
value = "";
|
|
}
|
|
while (*value) {
|
|
hash ^= static_cast<unsigned char>(*value++);
|
|
hash *= EDITOR_RENDER_HASH_MUL;
|
|
}
|
|
hash ^= 0;
|
|
hash *= EDITOR_RENDER_HASH_MUL;
|
|
return hash;
|
|
}
|
|
|
|
static unsigned int EditorHashMaterial(unsigned int hash, const idMaterial* material) {
|
|
return EditorHashString(hash, material ? material->GetName() : "");
|
|
}
|
|
|
|
static unsigned int EditorHashVec3(unsigned int hash, const idVec3& value) {
|
|
hash = EditorHashFloat(hash, value.x);
|
|
hash = EditorHashFloat(hash, value.y);
|
|
hash = EditorHashFloat(hash, value.z);
|
|
return hash;
|
|
}
|
|
|
|
static bool EditorVec3Changed(const idVec3& a, const idVec3& b) {
|
|
const float epsilon = 0.001f;
|
|
return idMath::Fabs(a.x - b.x) > epsilon ||
|
|
idMath::Fabs(a.y - b.y) > epsilon ||
|
|
idMath::Fabs(a.z - b.z) > epsilon;
|
|
}
|
|
|
|
static void EditorBrushRenderOrigin(brush_t* brush, idVec3& origin) {
|
|
origin[0] = (brush->mins[0] + brush->maxs[0]) * 0.5f;
|
|
origin[1] = (brush->mins[1] + brush->maxs[1]) * 0.5f;
|
|
origin[2] = (brush->mins[2] + brush->maxs[2]) * 0.5f;
|
|
}
|
|
|
|
static unsigned int EditorHashBrushGeometry(brush_t* brush, const idVec3& origin) {
|
|
unsigned int hash = EDITOR_RENDER_HASH_INIT;
|
|
|
|
hash = EditorHashInt(hash, brush->pPatch ? 1 : 0);
|
|
hash = EditorHashInt(hash, brush->modelHandle > 0 ? 1 : 0);
|
|
hash = EditorHashInt(hash, brush->entityModel ? 1 : 0);
|
|
|
|
if (brush->pPatch) {
|
|
patchMesh_t* pm = brush->pPatch;
|
|
|
|
hash = EditorHashInt(hash, pm->width);
|
|
hash = EditorHashInt(hash, pm->height);
|
|
hash = EditorHashInt(hash, pm->explicitSubdivisions ? 1 : 0);
|
|
hash = EditorHashInt(hash, pm->horzSubdivisions);
|
|
hash = EditorHashInt(hash, pm->vertSubdivisions);
|
|
hash = EditorHashMaterial(hash, pm->d_texture);
|
|
|
|
for (int i = 0; i < pm->width; i++) {
|
|
for (int j = 0; j < pm->height; j++) {
|
|
hash = EditorHashVec3(hash, pm->ctrl(i, j).xyz - origin);
|
|
hash = EditorHashFloat(hash, pm->ctrl(i, j).st.x);
|
|
hash = EditorHashFloat(hash, pm->ctrl(i, j).st.y);
|
|
}
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
for (face_t* face = brush->brush_faces; face; face = face->next) {
|
|
idWinding* w = face->face_winding;
|
|
if (!w) {
|
|
continue;
|
|
}
|
|
|
|
hash = EditorHashMaterial(hash, face->d_texture);
|
|
hash = EditorHashVec3(hash, face->plane.Normal());
|
|
hash = EditorHashInt(hash, w->GetNumPoints());
|
|
|
|
for (int i = 0; i < w->GetNumPoints(); i++) {
|
|
hash = EditorHashFloat(hash, (*w)[i][0] - origin[0]);
|
|
hash = EditorHashFloat(hash, (*w)[i][1] - origin[1]);
|
|
hash = EditorHashFloat(hash, (*w)[i][2] - origin[2]);
|
|
hash = EditorHashFloat(hash, (*w)[i][3]);
|
|
hash = EditorHashFloat(hash, (*w)[i][4]);
|
|
}
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
static unsigned int EditorHashBModelGeometry(entity_t* ent) {
|
|
unsigned int hash = EDITOR_RENDER_HASH_INIT;
|
|
hash = EditorHashString(hash, ValueForKey(ent, "name"));
|
|
|
|
for (brush_t* brush = ent->brushes.onext; brush != &ent->brushes; brush = brush->onext) {
|
|
const unsigned int brushHash = EditorHashBrushGeometry(brush, ent->origin);
|
|
hash = EditorHashInt(hash, brushHash);
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
static void EditorInitRenderEntityForModel(renderEntity_t& refent, idRenderModel* model, const idVec3& origin) {
|
|
memset(&refent, 0, sizeof(refent));
|
|
refent.hModel = model;
|
|
refent.origin = origin;
|
|
refent.axis = mat3_default;
|
|
refent.shaderParms[0] = 1;
|
|
refent.shaderParms[1] = 1;
|
|
refent.shaderParms[2] = 1;
|
|
refent.shaderParms[3] = 1;
|
|
}
|
|
|
|
static void EditorLocalizeTriSurfaces(idTriList& tris, const idVec3& origin) {
|
|
for (int i = 0; i < tris.Num(); i++) {
|
|
srfTriangles_t* tri = tris[i];
|
|
for (int j = 0; j < tri->numVerts; j++) {
|
|
tri->verts[j].xyz -= origin;
|
|
}
|
|
}
|
|
}
|
|
|
|
static idRenderModel* EditorBuildSingleBrushModel(brush_t* brush, const idVec3& origin) {
|
|
idTriList tris(1024);
|
|
idMatList mats(1024);
|
|
|
|
if (Brush_ToTris(brush, &tris, &mats, false, false) <= 0 || tris.Num() <= 0) {
|
|
return NULL;
|
|
}
|
|
|
|
EditorLocalizeTriSurfaces(tris, origin);
|
|
|
|
idRenderModel* model = renderModelManager->AllocModel();
|
|
model->InitEmpty(va("EditorBrushModel_%p", brush));
|
|
|
|
modelSurface_t surf;
|
|
for (int i = 0; i < tris.Num(); i++) {
|
|
surf.geometry = tris[i];
|
|
surf.shader = mats[i];
|
|
model->AddSurface(surf);
|
|
}
|
|
|
|
model->FinishSurfaces();
|
|
return model;
|
|
}
|
|
|
|
static idRenderModel* EditorBuildBModel(entity_t* ent, const char* name) {
|
|
idTriList tris(1024);
|
|
idMatList mats(1024);
|
|
|
|
for (brush_t* brush = ent->brushes.onext; brush != &ent->brushes; brush = brush->onext) {
|
|
Brush_ToTris(brush, &tris, &mats, false, true);
|
|
}
|
|
|
|
if (tris.Num() <= 0) {
|
|
return NULL;
|
|
}
|
|
|
|
idRenderModel* model = renderModelManager->AllocModel();
|
|
model->InitEmpty(name);
|
|
|
|
modelSurface_t surf;
|
|
for (int i = 0; i < tris.Num(); i++) {
|
|
surf.geometry = tris[i];
|
|
surf.shader = mats[i];
|
|
model->AddSurface(surf);
|
|
}
|
|
|
|
model->FinishSurfaces();
|
|
return model;
|
|
}
|
|
|
|
static void EditorFreeRenderEntityAuxData(int modelDef) {
|
|
if (modelDef < 0) {
|
|
return;
|
|
}
|
|
|
|
renderEntity_t* refent = const_cast<renderEntity_t*>(g_qeglobals.rw->GetRenderEntity(modelDef));
|
|
if (!refent) {
|
|
return;
|
|
}
|
|
|
|
if (refent->callbackData) {
|
|
Mem_Free(refent->callbackData);
|
|
refent->callbackData = NULL;
|
|
}
|
|
|
|
if (refent->joints) {
|
|
Mem_Free16(refent->joints);
|
|
refent->joints = NULL;
|
|
}
|
|
}
|
|
|
|
static void EditorFreeRenderEntityDef(int& modelDef) {
|
|
if (modelDef < 0) {
|
|
return;
|
|
}
|
|
EditorFreeRenderEntityAuxData(modelDef);
|
|
g_qeglobals.rw->FreeEntityDef(modelDef);
|
|
modelDef = -1;
|
|
}
|
|
|
|
static void EditorFreeRenderLightDef(int& lightDef) {
|
|
if (lightDef < 0) {
|
|
return;
|
|
}
|
|
g_qeglobals.rw->FreeLightDef(lightDef);
|
|
lightDef = -1;
|
|
}
|
|
|
|
static void EditorUpdateOrAddEntityDef(int& modelDef, const renderEntity_t* refent) {
|
|
if (modelDef >= 0) {
|
|
EditorFreeRenderEntityAuxData(modelDef);
|
|
g_qeglobals.rw->UpdateEntityDef(modelDef, refent);
|
|
}
|
|
else {
|
|
modelDef = g_qeglobals.rw->AddEntityDef(refent);
|
|
}
|
|
}
|
|
|
|
static int EditorFindWorldBrushState(brush_t* brush) {
|
|
for (int i = 0; i < s_editorWorldBrushStates.Num(); i++) {
|
|
if (s_editorWorldBrushStates[i].brush == brush) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static void EditorFreeWorldBrushState(int index) {
|
|
editorRenderWorldBrushState_t& state = s_editorWorldBrushStates[index];
|
|
|
|
EditorFreeRenderEntityDef(state.modelDef);
|
|
|
|
if (state.model) {
|
|
renderModelManager->FreeModel(state.model);
|
|
state.model = NULL;
|
|
}
|
|
|
|
s_editorWorldBrushStates.RemoveIndex(index);
|
|
}
|
|
|
|
static bool EditorWorldBrushRenderable(CCamWnd* cam, brush_t* brush) {
|
|
if (brush->hiddenBrush) {
|
|
return false;
|
|
}
|
|
if (FilterBrush(brush)) {
|
|
return false;
|
|
}
|
|
if (cam->CullBrush(brush, true)) {
|
|
return false;
|
|
}
|
|
if (IsBModel(brush)) {
|
|
return false;
|
|
}
|
|
if (brush->modelHandle > 0) {
|
|
return false;
|
|
}
|
|
if (brush->owner->eclass->fixedsize && !brush->entityModel) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void EditorReconcileWorldBrushState(CCamWnd* cam, brush_t* brush) {
|
|
if (!EditorWorldBrushRenderable(cam, brush)) {
|
|
return;
|
|
}
|
|
|
|
idVec3 origin;
|
|
EditorBrushRenderOrigin(brush, origin);
|
|
|
|
const unsigned int geometryHash = EditorHashBrushGeometry(brush, origin);
|
|
int index = EditorFindWorldBrushState(brush);
|
|
|
|
if (index < 0) {
|
|
editorRenderWorldBrushState_t newState;
|
|
newState.brush = brush;
|
|
newState.model = NULL;
|
|
newState.modelDef = -1;
|
|
newState.geometryHash = 0;
|
|
newState.origin = origin;
|
|
newState.touched = true;
|
|
s_editorWorldBrushStates.Append(newState);
|
|
index = s_editorWorldBrushStates.Num() - 1;
|
|
}
|
|
|
|
editorRenderWorldBrushState_t& state = s_editorWorldBrushStates[index];
|
|
state.touched = true;
|
|
|
|
const bool geometryChanged = (state.model == NULL || state.geometryHash != geometryHash);
|
|
|
|
if (geometryChanged) {
|
|
idRenderModel* newModel = EditorBuildSingleBrushModel(brush, origin);
|
|
if (!newModel) {
|
|
EditorFreeWorldBrushState(index);
|
|
return;
|
|
}
|
|
|
|
idRenderModel* oldModel = state.model;
|
|
state.model = newModel;
|
|
state.geometryHash = geometryHash;
|
|
|
|
renderEntity_t refent;
|
|
EditorInitRenderEntityForModel(refent, state.model, origin);
|
|
EditorUpdateOrAddEntityDef(state.modelDef, &refent);
|
|
|
|
if (oldModel) {
|
|
renderModelManager->FreeModel(oldModel);
|
|
}
|
|
|
|
state.origin = origin;
|
|
return;
|
|
}
|
|
|
|
if (EditorVec3Changed(state.origin, origin)) {
|
|
renderEntity_t refent;
|
|
EditorInitRenderEntityForModel(refent, state.model, origin);
|
|
EditorUpdateOrAddEntityDef(state.modelDef, &refent);
|
|
state.origin = origin;
|
|
}
|
|
}
|
|
|
|
static void EditorBeginWorldBrushReconcile() {
|
|
for (int i = 0; i < s_editorWorldBrushStates.Num(); i++) {
|
|
s_editorWorldBrushStates[i].touched = false;
|
|
}
|
|
}
|
|
|
|
static void EditorPurgeUntouchedWorldBrushStates() {
|
|
for (int i = s_editorWorldBrushStates.Num() - 1; i >= 0; i--) {
|
|
if (!s_editorWorldBrushStates[i].touched) {
|
|
EditorFreeWorldBrushState(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int EditorFindEntityState(entity_t* ent) {
|
|
for (int i = 0; i < s_editorEntityStates.Num(); i++) {
|
|
if (s_editorEntityStates[i].ent == ent) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static editorRenderEntityState_t* EditorTouchEntityState(entity_t* ent) {
|
|
int index = EditorFindEntityState(ent);
|
|
|
|
if (index < 0) {
|
|
editorRenderEntityState_t newState;
|
|
newState.ent = ent;
|
|
newState.modelDef = ent->modelDef;
|
|
newState.lightDef = ent->lightDef;
|
|
newState.touched = true;
|
|
s_editorEntityStates.Append(newState);
|
|
index = s_editorEntityStates.Num() - 1;
|
|
}
|
|
|
|
editorRenderEntityState_t& state = s_editorEntityStates[index];
|
|
state.touched = true;
|
|
|
|
if (state.modelDef < 0 && ent->modelDef >= 0) {
|
|
state.modelDef = ent->modelDef;
|
|
}
|
|
if (state.lightDef < 0 && ent->lightDef >= 0) {
|
|
state.lightDef = ent->lightDef;
|
|
}
|
|
|
|
ent->modelDef = state.modelDef;
|
|
ent->lightDef = state.lightDef;
|
|
|
|
return &state;
|
|
}
|
|
|
|
static void EditorFreeEntityModelDef(editorRenderEntityState_t* state, entity_t* ent) {
|
|
EditorFreeRenderEntityDef(state->modelDef);
|
|
if (ent) {
|
|
ent->modelDef = state->modelDef;
|
|
}
|
|
}
|
|
|
|
static void EditorFreeEntityLightDef(editorRenderEntityState_t* state, entity_t* ent) {
|
|
EditorFreeRenderLightDef(state->lightDef);
|
|
if (ent) {
|
|
ent->lightDef = state->lightDef;
|
|
}
|
|
}
|
|
|
|
static void EditorUpdateOrAddEntityModelDef(editorRenderEntityState_t* state, entity_t* ent, const renderEntity_t* refent) {
|
|
EditorUpdateOrAddEntityDef(state->modelDef, refent);
|
|
ent->modelDef = state->modelDef;
|
|
}
|
|
|
|
static void EditorUpdateOrAddEntityLightDef(editorRenderEntityState_t* state, entity_t* ent, const renderLight_t* lightParms) {
|
|
if (state->lightDef >= 0) {
|
|
g_qeglobals.rw->UpdateLightDef(state->lightDef, lightParms);
|
|
}
|
|
else {
|
|
state->lightDef = g_qeglobals.rw->AddLightDef(lightParms);
|
|
}
|
|
ent->lightDef = state->lightDef;
|
|
}
|
|
|
|
static void EditorBeginEntityReconcile() {
|
|
for (int i = 0; i < s_editorEntityStates.Num(); i++) {
|
|
s_editorEntityStates[i].touched = false;
|
|
}
|
|
for (int i = 0; i < s_editorBModelStates.Num(); i++) {
|
|
s_editorBModelStates[i].touched = false;
|
|
}
|
|
}
|
|
|
|
static void EditorPurgeUntouchedEntityStates() {
|
|
for (int i = s_editorEntityStates.Num() - 1; i >= 0; i--) {
|
|
if (s_editorEntityStates[i].touched) {
|
|
continue;
|
|
}
|
|
|
|
EditorFreeRenderEntityDef(s_editorEntityStates[i].modelDef);
|
|
EditorFreeRenderLightDef(s_editorEntityStates[i].lightDef);
|
|
s_editorEntityStates.RemoveIndex(i);
|
|
}
|
|
}
|
|
|
|
static int EditorFindBModelState(entity_t* ent) {
|
|
for (int i = 0; i < s_editorBModelStates.Num(); i++) {
|
|
if (s_editorBModelStates[i].ent == ent) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static editorRenderBModelState_t* EditorTouchBModelState(entity_t* ent) {
|
|
int index = EditorFindBModelState(ent);
|
|
|
|
if (index < 0) {
|
|
editorRenderBModelState_t newState;
|
|
newState.ent = ent;
|
|
newState.model = NULL;
|
|
newState.modelName = "";
|
|
newState.geometryHash = 0;
|
|
newState.touched = true;
|
|
s_editorBModelStates.Append(newState);
|
|
index = s_editorBModelStates.Num() - 1;
|
|
}
|
|
|
|
s_editorBModelStates[index].touched = true;
|
|
return &s_editorBModelStates[index];
|
|
}
|
|
|
|
static void EditorFreeBModelState(int index) {
|
|
editorRenderBModelState_t& state = s_editorBModelStates[index];
|
|
|
|
if (state.model) {
|
|
renderModelManager->RemoveModel(state.model);
|
|
renderModelManager->FreeModel(state.model);
|
|
state.model = NULL;
|
|
}
|
|
|
|
s_editorBModelStates.RemoveIndex(index);
|
|
}
|
|
|
|
static void EditorFreeBModelStateForEntity(entity_t* ent) {
|
|
const int index = EditorFindBModelState(ent);
|
|
if (index >= 0) {
|
|
EditorFreeBModelState(index);
|
|
}
|
|
}
|
|
|
|
static void EditorPurgeUntouchedBModelStates() {
|
|
for (int i = s_editorBModelStates.Num() - 1; i >= 0; i--) {
|
|
if (!s_editorBModelStates[i].touched) {
|
|
EditorFreeBModelState(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CCamWnd::BuildEntityRenderState(entity_t* ent, bool update) {
|
|
const char* v;
|
|
idDict spawnArgs;
|
|
const char* name = NULL;
|
|
editorRenderEntityState_t* entityState = EditorTouchEntityState(ent);
|
|
|
|
// The old code used update=false as "tear down and recreate". The
|
|
// incremental path keeps the handles and uses UpdateEntityDef /
|
|
// UpdateLightDef when possible.
|
|
(void)update;
|
|
|
|
Entity_UpdateSoundEmitter(ent);
|
|
|
|
// If the entity is no longer renderable, remove only this entity's defs.
|
|
if (ent->brushes.onext == &ent->brushes ||
|
|
FilterBrush(ent->brushes.onext) ||
|
|
CullBrush(ent->brushes.onext, true) ||
|
|
Map_IsBrushFiltered(ent->brushes.onext)) {
|
|
EditorFreeEntityModelDef(entityState, ent);
|
|
EditorFreeEntityLightDef(entityState, ent);
|
|
EditorFreeBModelStateForEntity(ent);
|
|
return;
|
|
}
|
|
|
|
spawnArgs = ent->epairs;
|
|
if (ent->eclass->defArgs.FindKey("model")) {
|
|
spawnArgs.Set("model", ent->eclass->defArgs.GetString("model"));
|
|
}
|
|
|
|
// any entity can have a model
|
|
name = ValueForKey(ent, "name");
|
|
v = spawnArgs.GetString("model");
|
|
if (v && *v) {
|
|
renderEntity_t refent;
|
|
memset(&refent, 0, sizeof(refent));
|
|
|
|
if (!stricmp(name, v)) {
|
|
// Brush model entity. Rebuild the renderModel only when the
|
|
// entity-local brush geometry/materials changed. Plain movement
|
|
// is handled by UpdateEntityDef below.
|
|
const unsigned int geometryHash = EditorHashBModelGeometry(ent);
|
|
editorRenderBModelState_t* bmodelState = EditorTouchBModelState(ent);
|
|
idRenderModel* oldModel = NULL;
|
|
|
|
const bool geometryChanged =
|
|
(bmodelState->model == NULL ||
|
|
bmodelState->geometryHash != geometryHash ||
|
|
idStr::Icmp(bmodelState->modelName.c_str(), name) != 0);
|
|
|
|
if (geometryChanged) {
|
|
idRenderModel* newModel = EditorBuildBModel(ent, name);
|
|
if (newModel) {
|
|
oldModel = bmodelState->model;
|
|
bmodelState->model = newModel;
|
|
bmodelState->modelName = name;
|
|
bmodelState->geometryHash = geometryHash;
|
|
}
|
|
else {
|
|
EditorFreeEntityModelDef(entityState, ent);
|
|
EditorFreeBModelStateForEntity(ent);
|
|
bmodelState = NULL;
|
|
}
|
|
}
|
|
|
|
if (bmodelState && bmodelState->model) {
|
|
gameEdit->ParseSpawnArgsToRenderEntity(&spawnArgs, &refent);
|
|
refent.hModel = bmodelState->model;
|
|
refent.referenceSound = ent->soundEmitter;
|
|
EditorUpdateOrAddEntityModelDef(entityState, ent, &refent);
|
|
|
|
if (geometryChanged) {
|
|
if (oldModel) {
|
|
renderModelManager->RemoveModel(oldModel);
|
|
renderModelManager->FreeModel(oldModel);
|
|
}
|
|
renderModelManager->AddModel(bmodelState->model);
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
// use the game's epair parsing code so
|
|
// we can use the same renderEntity generation
|
|
EditorFreeBModelStateForEntity(ent);
|
|
|
|
gameEdit->ParseSpawnArgsToRenderEntity(&spawnArgs, &refent);
|
|
refent.referenceSound = ent->soundEmitter;
|
|
|
|
idRenderModelMD5* md5 = dynamic_cast<idRenderModelMD5*>(refent.hModel);
|
|
if (md5) {
|
|
idStr str;
|
|
spawnArgs.GetString("anim", "idle", str);
|
|
refent.numJoints = md5->NumJoints();
|
|
refent.joints = (idJointMat*)Mem_Alloc16(refent.numJoints * sizeof(*refent.joints));
|
|
const idMD5Anim* anim = gameEdit->ANIM_GetAnimFromEntityDef(spawnArgs.GetString("classname"), str);
|
|
int frame = spawnArgs.GetInt("frame") + 1;
|
|
if (frame < 1) {
|
|
frame = 1;
|
|
}
|
|
const idVec3& offset = gameEdit->ANIM_GetModelOffsetFromEntityDef(spawnArgs.GetString("classname"));
|
|
gameEdit->ANIM_CreateAnimFrame(md5, anim, refent.numJoints, refent.joints, (frame * 1000) / 24, offset, false);
|
|
}
|
|
|
|
EditorUpdateOrAddEntityModelDef(entityState, ent, &refent);
|
|
}
|
|
}
|
|
else {
|
|
EditorFreeEntityModelDef(entityState, ent);
|
|
EditorFreeBModelStateForEntity(ent);
|
|
}
|
|
|
|
// check for lightdefs
|
|
if (!(ent->eclass->nShowFlags & ECLASS_LIGHT) || spawnArgs.GetBool("start_off")) {
|
|
EditorFreeEntityLightDef(entityState, ent);
|
|
return;
|
|
}
|
|
|
|
// use the game's epair parsing code so
|
|
// we can use the same renderLight generation
|
|
renderLight_t lightParms;
|
|
gameEdit->ParseSpawnArgsToRenderLight(&spawnArgs, &lightParms);
|
|
lightParms.referenceSound = ent->soundEmitter;
|
|
|
|
EditorUpdateOrAddEntityLightDef(entityState, ent, &lightParms);
|
|
}
|
|
|
|
|
|
void Tris_ToOBJ(const char* outFile, idTriList* tris, idMatList* mats) {
|
|
idFile* f = fileSystem->OpenExplicitFileWrite(outFile);
|
|
if (f) {
|
|
char out[1024];
|
|
strcpy(out, outFile);
|
|
StripExtension(out);
|
|
|
|
idList<idStr*> matNames;
|
|
int i, j, k;
|
|
int indexBase = 1;
|
|
idStr lastMaterial("");
|
|
int matCount = 0;
|
|
//idStr basePath = cvarSystem->GetCVarString( "fs_savepath" );
|
|
f->Printf("mtllib %s.mtl\n", out);
|
|
for (i = 0; i < tris->Num(); i++) {
|
|
srfTriangles_t* tri = (*tris)[i];
|
|
for (j = 0; j < tri->numVerts; j++) {
|
|
f->Printf("v %f %f %f\n", tri->verts[j].xyz.x, tri->verts[j].xyz.z, -tri->verts[j].xyz.y);
|
|
}
|
|
for (j = 0; j < tri->numVerts; j++) {
|
|
f->Printf("vt %f %f\n", tri->verts[j].st.x, 1.0f - tri->verts[j].st.y);
|
|
}
|
|
for (j = 0; j < tri->numVerts; j++) {
|
|
f->Printf("vn %f %f %f\n", tri->verts[j].normal.x, tri->verts[j].normal.y, tri->verts[j].normal.z);
|
|
}
|
|
|
|
if (stricmp((*mats)[i]->GetName(), lastMaterial)) {
|
|
lastMaterial = (*mats)[i]->GetName();
|
|
|
|
bool found = false;
|
|
for (k = 0; k < matNames.Num(); k++) {
|
|
if (idStr::Icmp(matNames[k]->c_str(), lastMaterial.c_str()) == 0) {
|
|
found = true;
|
|
// f->Printf( "usemtl m%i\n", k );
|
|
f->Printf("usemtl %s\n", lastMaterial.c_str());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
// f->Printf( "usemtl m%i\n", matCount++ );
|
|
f->Printf("usemtl %s\n", lastMaterial.c_str());
|
|
matNames.Append(new idStr(lastMaterial));
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < tri->numIndexes; j += 3) {
|
|
int i1, i2, i3;
|
|
i1 = tri->indexes[j + 2] + indexBase;
|
|
i2 = tri->indexes[j + 1] + indexBase;
|
|
i3 = tri->indexes[j] + indexBase;
|
|
f->Printf("f %i/%i/%i %i/%i/%i %i/%i/%i\n", i1, i1, i1, i2, i2, i2, i3, i3, i3);
|
|
}
|
|
|
|
indexBase += tri->numVerts;
|
|
|
|
}
|
|
fileSystem->CloseFile(f);
|
|
|
|
strcat(out, ".mtl");
|
|
f = fileSystem->OpenExplicitFileWrite(out);
|
|
if (f) {
|
|
for (k = 0; k < matNames.Num(); k++) {
|
|
// This presumes the diffuse tga name matches the material name
|
|
f->Printf("newmtl %s\n\tNs 0\n\td 1\n\tillum 2\n\tKd 0 0 0 \n\tKs 0.22 0.22 0.22 \n\tKa 0 0 0 \n\tmap_Kd %s/base/%s.tga\n\n\n", matNames[k]->c_str(), "z:/d3xp", matNames[k]->c_str());
|
|
}
|
|
fileSystem->CloseFile(f);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
int Brush_TransformModel(brush_t* brush, idTriList* tris, idMatList* mats) {
|
|
int ret = 0;
|
|
if (brush->modelHandle > 0) {
|
|
idRenderModel* model = brush->modelHandle;
|
|
if (model) {
|
|
float a = FloatForKey(brush->owner, "angle");
|
|
float s, c;
|
|
//FIXME: support full rotation matrix
|
|
bool matrix = false;
|
|
if (a) {
|
|
s = sin(DEG2RAD(a));
|
|
c = cos(DEG2RAD(a));
|
|
}
|
|
idMat3 mat;
|
|
if (GetMatrixForKey(brush->owner, "rotation", mat)) {
|
|
matrix = true;
|
|
}
|
|
|
|
|
|
for (int i = 0; i < model->NumSurfaces(); i++) {
|
|
const modelSurface_t* surf = model->Surface(i);
|
|
srfTriangles_t* tri = surf->geometry;
|
|
srfTriangles_t* tri2 = R_CopyStaticTriSurf(tri);
|
|
for (int j = 0; j < tri2->numVerts; j++) {
|
|
idVec3 v;
|
|
if (matrix) {
|
|
v = tri2->verts[j].xyz * brush->owner->rotation + brush->owner->origin;
|
|
}
|
|
else {
|
|
v = tri2->verts[j].xyz;
|
|
VectorAdd(v, brush->owner->origin, v);
|
|
float x = v[0];
|
|
float y = v[1];
|
|
if (a) {
|
|
float x2 = (((x - brush->owner->origin[0]) * c) - ((y - brush->owner->origin[1]) * s)) + brush->owner->origin[0];
|
|
float y2 = (((x - brush->owner->origin[0]) * s) + ((y - brush->owner->origin[1]) * c)) + brush->owner->origin[1];
|
|
x = x2;
|
|
y = y2;
|
|
}
|
|
v[0] = x;
|
|
v[1] = y;
|
|
}
|
|
tri2->verts[j].xyz = v;
|
|
}
|
|
tris->Append(tri2);
|
|
mats->Append(surf->shader);
|
|
}
|
|
return model->NumSurfaces();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
#define MAX_TRI_SURFACES 16384
|
|
int Brush_ToTris(brush_t* brush, idTriList* tris, idMatList* mats, bool models, bool bmodel) {
|
|
int i, j;
|
|
srfTriangles_t* tri;
|
|
//
|
|
// patches
|
|
//
|
|
if (brush->modelHandle > 0) {
|
|
if (!models) {
|
|
return 0;
|
|
}
|
|
else {
|
|
return Brush_TransformModel(brush, tris, mats);
|
|
}
|
|
}
|
|
|
|
int numSurfaces = 0;
|
|
|
|
if (brush->owner->eclass->fixedsize && !brush->entityModel) {
|
|
return NULL;
|
|
}
|
|
|
|
if (brush->pPatch) {
|
|
patchMesh_t* pm;
|
|
int width, height;
|
|
|
|
pm = brush->pPatch;
|
|
|
|
// build a patch mesh
|
|
idSurface_Patch* cp = new idSurface_Patch(pm->width * 6, pm->height * 6);
|
|
cp->SetSize(pm->width, pm->height);
|
|
for (i = 0; i < pm->width; i++) {
|
|
for (j = 0; j < pm->height; j++) {
|
|
(*cp)[j * cp->GetWidth() + i].xyz = pm->ctrl(i, j).xyz;
|
|
(*cp)[j * cp->GetWidth() + i].st = pm->ctrl(i, j).st;
|
|
}
|
|
}
|
|
|
|
// subdivide it
|
|
if (pm->explicitSubdivisions) {
|
|
cp->SubdivideExplicit(pm->horzSubdivisions, pm->vertSubdivisions, true);
|
|
}
|
|
else {
|
|
cp->Subdivide(DEFAULT_CURVE_MAX_ERROR, DEFAULT_CURVE_MAX_ERROR, DEFAULT_CURVE_MAX_LENGTH, true);
|
|
}
|
|
width = cp->GetWidth();
|
|
height = cp->GetHeight();
|
|
|
|
// convert to srfTriangles
|
|
tri = R_AllocStaticTriSurf();
|
|
tri->numVerts = width * height;
|
|
tri->numIndexes = 6 * (width - 1) * (height - 1);
|
|
R_AllocStaticTriSurfVerts(tri, tri->numVerts);
|
|
R_AllocStaticTriSurfIndexes(tri, tri->numIndexes);
|
|
for (i = 0; i < tri->numVerts; i++) {
|
|
tri->verts[i] = (*cp)[i];
|
|
if (bmodel) {
|
|
tri->verts[i].xyz -= brush->owner->origin;
|
|
}
|
|
}
|
|
|
|
tri->numIndexes = 0;
|
|
for (i = 1; i < width; i++) {
|
|
for (j = 1; j < height; j++) {
|
|
tri->indexes[tri->numIndexes++] = (j - 1) * width + i;
|
|
tri->indexes[tri->numIndexes++] = (j - 1) * width + i - 1;
|
|
tri->indexes[tri->numIndexes++] = j * width + i - 1;
|
|
|
|
tri->indexes[tri->numIndexes++] = j * width + i;
|
|
tri->indexes[tri->numIndexes++] = (j - 1) * width + i;
|
|
tri->indexes[tri->numIndexes++] = j * width + i - 1;
|
|
}
|
|
}
|
|
|
|
delete cp;
|
|
|
|
tris->Append(tri);
|
|
mats->Append(pm->d_texture);
|
|
//surfaces[numSurfaces] = tri;
|
|
//materials[numSurfaces] = pm->d_texture;
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// normal brush
|
|
//
|
|
for (face_t* face = brush->brush_faces; face; face = face->next) {
|
|
idWinding* w;
|
|
|
|
w = face->face_winding;
|
|
if (!w) {
|
|
continue; // freed or degenerate face
|
|
}
|
|
|
|
tri = R_AllocStaticTriSurf();
|
|
tri->numVerts = w->GetNumPoints();
|
|
tri->numIndexes = (w->GetNumPoints() - 2) * 3;
|
|
R_AllocStaticTriSurfVerts(tri, tri->numVerts);
|
|
R_AllocStaticTriSurfIndexes(tri, tri->numIndexes);
|
|
|
|
for (i = 0; i < tri->numVerts; i++) {
|
|
|
|
tri->verts[i].Clear();
|
|
|
|
tri->verts[i].xyz[0] = (*w)[i][0];
|
|
tri->verts[i].xyz[1] = (*w)[i][1];
|
|
tri->verts[i].xyz[2] = (*w)[i][2];
|
|
|
|
if (bmodel) {
|
|
tri->verts[i].xyz -= brush->owner->origin;
|
|
}
|
|
|
|
tri->verts[i].st[0] = (*w)[i][3];
|
|
tri->verts[i].st[1] = (*w)[i][4];
|
|
|
|
tri->verts[i].normal = face->plane.Normal();
|
|
}
|
|
|
|
tri->numIndexes = 0;
|
|
for (i = 2; i < w->GetNumPoints(); i++) {
|
|
tri->indexes[tri->numIndexes++] = 0;
|
|
tri->indexes[tri->numIndexes++] = i - 1;
|
|
tri->indexes[tri->numIndexes++] = i;
|
|
}
|
|
|
|
tris->Append(tri);
|
|
mats->Append(face->d_texture);
|
|
numSurfaces++;
|
|
}
|
|
|
|
return numSurfaces;
|
|
}
|
|
|
|
void Select_ToOBJ() {
|
|
int i;
|
|
CFileDialog dlgFile(FALSE, "obj", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "Wavefront object files (*.obj)|*.obj||", g_pParentWnd);
|
|
if (dlgFile.DoModal() == IDOK) {
|
|
idTriList tris(1024);
|
|
idMatList mats(1024);
|
|
|
|
for (brush_t* b = selected_brushes.next; b != &selected_brushes; b = b->next) {
|
|
|
|
if (b->hiddenBrush) {
|
|
continue;
|
|
}
|
|
|
|
if (FilterBrush(b)) {
|
|
continue;
|
|
}
|
|
|
|
Brush_ToTris(b, &tris, &mats, true, false);
|
|
}
|
|
|
|
Tris_ToOBJ(dlgFile.GetPathName().GetBuffer(0), &tris, &mats);
|
|
|
|
for (i = 0; i < tris.Num(); i++) {
|
|
R_FreeStaticTriSurf(tris[i]);
|
|
}
|
|
tris.Clear();
|
|
}
|
|
}
|
|
|
|
void Select_ToCM() {
|
|
CFileDialog dlgFile(FALSE, "lwo, ase", NULL, 0, "(*.lwo)|*.lwo|(*.ase)|*.ase|(*.ma)|*.ma||", g_pParentWnd);
|
|
|
|
if (dlgFile.DoModal() == IDOK) {
|
|
idMapEntity* mapEnt;
|
|
idMapPrimitive* p;
|
|
idStr name;
|
|
|
|
name = fileSystem->OSPathToRelativePath(dlgFile.GetPathName());
|
|
name.BackSlashesToSlashes();
|
|
|
|
mapEnt = new idMapEntity();
|
|
mapEnt->epairs.Set("name", name.c_str());
|
|
|
|
for (brush_t* b = selected_brushes.next; b != &selected_brushes; b = b->next) {
|
|
|
|
if (b->hiddenBrush) {
|
|
continue;
|
|
}
|
|
|
|
if (FilterBrush(b)) {
|
|
continue;
|
|
}
|
|
|
|
p = BrushToMapPrimitive(b, b->owner->origin);
|
|
if (p) {
|
|
mapEnt->AddPrimitive(p);
|
|
}
|
|
}
|
|
|
|
collisionModelManager->WriteCollisionModelForMapEntity(mapEnt, name.c_str());
|
|
|
|
delete mapEnt;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
BuildRendererState
|
|
|
|
Builds models, lightdefs, and modeldefs for the current editor data
|
|
so it can be rendered by the game renderSystem
|
|
=================
|
|
*/
|
|
void CCamWnd::BuildRendererState() {
|
|
entity_t* ent;
|
|
brush_t* brush;
|
|
|
|
if (!s_editorRenderWorldInitialized) {
|
|
// First build, or after FreeRendererState(). Do not do this on every
|
|
// dirty frame; it drops all defs from the renderWorld.
|
|
g_qeglobals.rw->InitFromMap(NULL);
|
|
s_editorRenderWorldInitialized = true;
|
|
}
|
|
|
|
// Compatibility cleanup for any old monolithic world model that may still
|
|
// exist from a previous build path.
|
|
if (worldModelDef >= 0) {
|
|
g_qeglobals.rw->FreeEntityDef(worldModelDef);
|
|
worldModelDef = -1;
|
|
}
|
|
|
|
if (worldModel) {
|
|
renderModelManager->FreeModel(worldModel);
|
|
worldModel = NULL;
|
|
}
|
|
|
|
EditorBeginWorldBrushReconcile();
|
|
|
|
for (brush_t* brushList = &active_brushes; brushList;
|
|
brushList = (brushList == &active_brushes) ? &selected_brushes : NULL) {
|
|
|
|
for (brush = brushList->next; brush != brushList; brush = brush->next) {
|
|
EditorReconcileWorldBrushState(this, brush);
|
|
}
|
|
}
|
|
|
|
EditorPurgeUntouchedWorldBrushStates();
|
|
|
|
// Create/update/remove the light and model entities exactly the way the
|
|
// game code would, but without destroying unrelated renderWorld defs.
|
|
EditorBeginEntityReconcile();
|
|
|
|
for (ent = entities.next; ent != &entities; ent = ent->next) {
|
|
BuildEntityRenderState(ent, true);
|
|
}
|
|
|
|
EditorPurgeUntouchedEntityStates();
|
|
EditorPurgeUntouchedBModelStates();
|
|
|
|
worldDirty = false;
|
|
}
|
|
|
|
/*
|
|
===============================
|
|
CCamWnd::UpdateRenderEntities
|
|
|
|
Creates a new entity state list
|
|
returns true if a repaint is needed
|
|
===============================
|
|
*/
|
|
bool CCamWnd::UpdateRenderEntities() {
|
|
|
|
if (rebuildMode) {
|
|
return false;
|
|
}
|
|
|
|
if (!s_editorRenderWorldInitialized) {
|
|
g_qeglobals.rw->InitFromMap(NULL);
|
|
s_editorRenderWorldInitialized = true;
|
|
}
|
|
|
|
bool ret = false;
|
|
EditorBeginEntityReconcile();
|
|
|
|
for (entity_t* ent = entities.next; ent != &entities; ent = ent->next) {
|
|
BuildEntityRenderState(ent, true);
|
|
if (!ret && (ent->modelDef >= 0 || ent->lightDef >= 0)) {
|
|
ret = true;
|
|
}
|
|
}
|
|
|
|
EditorPurgeUntouchedEntityStates();
|
|
EditorPurgeUntouchedBModelStates();
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
============================
|
|
CCamWnd::FreeRendererState
|
|
|
|
Frees the render state data
|
|
============================
|
|
*/
|
|
void CCamWnd::FreeRendererState() {
|
|
|
|
for (int i = s_editorEntityStates.Num() - 1; i >= 0; i--) {
|
|
EditorFreeRenderEntityDef(s_editorEntityStates[i].modelDef);
|
|
EditorFreeRenderLightDef(s_editorEntityStates[i].lightDef);
|
|
s_editorEntityStates.RemoveIndex(i);
|
|
}
|
|
|
|
if (entities.next != NULL)
|
|
{
|
|
for (entity_t* ent = entities.next; ent != &entities; ent = ent->next) {
|
|
ent->modelDef = -1;
|
|
ent->lightDef = -1;
|
|
}
|
|
}
|
|
|
|
|
|
for (int i = s_editorBModelStates.Num() - 1; i >= 0; i--) {
|
|
EditorFreeBModelState(i);
|
|
}
|
|
|
|
for (int i = s_editorWorldBrushStates.Num() - 1; i >= 0; i--) {
|
|
EditorFreeWorldBrushState(i);
|
|
}
|
|
|
|
if (worldModelDef >= 0) {
|
|
g_qeglobals.rw->FreeEntityDef(worldModelDef);
|
|
worldModelDef = -1;
|
|
}
|
|
|
|
if (worldModel) {
|
|
renderModelManager->FreeModel(worldModel);
|
|
worldModel = NULL;
|
|
}
|
|
|
|
s_editorRenderWorldInitialized = false;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
========================
|
|
CCamWnd::UpdateCaption
|
|
|
|
updates the caption based on rendermode and whether the render mode needs updated
|
|
========================
|
|
*/
|
|
void CCamWnd::UpdateCaption() {
|
|
|
|
idStr strCaption;
|
|
|
|
if (worldDirty) {
|
|
strCaption = "*";
|
|
}
|
|
// FIXME:
|
|
strCaption += (renderMode) ? "RENDER" : "CAM";
|
|
if (renderMode) {
|
|
strCaption += (rebuildMode) ? " (Realtime)" : "";
|
|
strCaption += (entityMode) ? " +lights" : "";
|
|
strCaption += (selectMode) ? " +selected" : "";
|
|
strCaption += (animationMode) ? " +anim" : "";
|
|
}
|
|
strCaption += (soundMode) ? " +snd" : "";
|
|
SetWindowText(strCaption);
|
|
}
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleRenderMode
|
|
|
|
Toggles the render mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleRenderMode() {
|
|
renderMode ^= 1;
|
|
UpdateCaption();
|
|
}
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleRebuildMode
|
|
|
|
Toggles the rebuild mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleRebuildMode() {
|
|
rebuildMode ^= 1;
|
|
UpdateCaption();
|
|
}
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleEntityMode
|
|
|
|
Toggles the entity mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleEntityMode() {
|
|
entityMode ^= 1;
|
|
UpdateCaption();
|
|
}
|
|
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleRenderMode
|
|
|
|
Toggles the render mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleAnimationMode() {
|
|
animationMode ^= 1;
|
|
if (animationMode) {
|
|
SetTimer(0, 10, NULL);
|
|
}
|
|
else {
|
|
KillTimer(0);
|
|
}
|
|
UpdateCaption();
|
|
}
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleSoundMode
|
|
|
|
Toggles the sound mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleSoundMode() {
|
|
soundMode ^= 1;
|
|
|
|
UpdateCaption();
|
|
|
|
for (entity_t* ent = entities.next; ent != &entities; ent = ent->next) {
|
|
Entity_UpdateSoundEmitter(ent);
|
|
}
|
|
}
|
|
|
|
/*
|
|
===========================
|
|
CCamWnd::ToggleRenderMode
|
|
|
|
Toggles the render mode
|
|
===========================
|
|
*/
|
|
void CCamWnd::ToggleSelectMode() {
|
|
selectMode ^= 1;
|
|
UpdateCaption();
|
|
}
|
|
|
|
/*
|
|
=========================
|
|
CCamWnd::MarkWorldDirty
|
|
|
|
marks the render world as dirty
|
|
=========================
|
|
*/
|
|
void CCamWnd::MarkWorldDirty() {
|
|
worldDirty = true;
|
|
UpdateCaption();
|
|
}
|
|
|
|
|
|
/*
|
|
=========================
|
|
CCamWnd::DrawEntityData
|
|
|
|
Draws entity data ( experimental )
|
|
=========================
|
|
*/
|
|
extern void glBox(idVec4& color, idVec3& point, float size);
|
|
|
|
void CCamWnd::DrawEntityData() {
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
|
|
SetProjectionMatrix();
|
|
|
|
glRotatef(-90, 1, 0, 0); // put Z going up
|
|
glRotatef(90, 0, 0, 1); // put Z going up
|
|
glRotatef(m_Camera.angles[0], 0, 1, 0);
|
|
glRotatef(-m_Camera.angles[1], 0, 0, 1);
|
|
glTranslatef(-m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
|
|
|
|
Cam_BuildMatrix();
|
|
|
|
if (!(entityMode || selectMode)) {
|
|
return;
|
|
}
|
|
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
globalImages->BindNull();
|
|
idVec3 color(0, 1, 0);
|
|
glColor3fv(color.ToFloatPtr());
|
|
|
|
brush_t* brushList = &active_brushes;
|
|
int pass = 0;
|
|
while (brushList) {
|
|
for (brush_t* brush = brushList->next; brush != brushList; brush = brush->next) {
|
|
|
|
if (CullBrush(brush, true)) {
|
|
continue;
|
|
}
|
|
|
|
if (FilterBrush(brush)) {
|
|
continue;
|
|
}
|
|
|
|
if ((pass == 1 && selectMode) || (entityMode && pass == 0 && brush->owner->lightDef >= 0)) {
|
|
Brush_DrawXY(brush, 0, true, true);
|
|
}
|
|
|
|
}
|
|
brushList = (brushList == &active_brushes) ? &selected_brushes : NULL;
|
|
color.x = 1;
|
|
color.y = 0;
|
|
pass++;
|
|
glColor3fv(color.ToFloatPtr());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Cam_Render
|
|
|
|
This used the renderSystem to draw a fully lit view of the world
|
|
=======================================================================================================================
|
|
*/
|
|
void CCamWnd::Cam_Render() {
|
|
|
|
renderView_t refdef;
|
|
CPaintDC dc(this); // device context for painting
|
|
|
|
|
|
if (!active_brushes.next) {
|
|
return; // not valid yet
|
|
}
|
|
|
|
// save the editor state
|
|
//glPushAttrib( GL_ALL_ATTRIB_BITS );
|
|
glClearColor(0.1f, 0.1f, 0.1f, 0.0f);
|
|
glScissor(0, 0, m_Camera.width, m_Camera.height);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
// wglSwapBuffers(dc.m_hDC);
|
|
|
|
// create the model, using explicit normals
|
|
BuildRendererState();
|
|
|
|
// render it
|
|
renderSystem->BeginFrame(m_Camera.width, m_Camera.height);
|
|
|
|
memset(&refdef, 0, sizeof(refdef));
|
|
refdef.vieworg = m_Camera.origin;
|
|
|
|
// the editor uses opposite pitch convention
|
|
refdef.viewaxis = idAngles(-m_Camera.angles.pitch, m_Camera.angles.yaw, m_Camera.angles.roll).ToMat3();
|
|
|
|
refdef.width = SCREEN_WIDTH;
|
|
refdef.height = SCREEN_HEIGHT;
|
|
refdef.fov_x = 90;
|
|
refdef.fov_y = 2 * atan((float)m_Camera.height / m_Camera.width) * idMath::M_RAD2DEG;
|
|
|
|
// only set in animation mode to give a consistent look
|
|
if (animationMode) {
|
|
refdef.time = eventLoop->Milliseconds();
|
|
}
|
|
|
|
g_qeglobals.rw->RenderScene(&refdef);
|
|
|
|
int frontEnd, backEnd;
|
|
|
|
renderSystem->EndFrame(&frontEnd, &backEnd, false);
|
|
//common->Printf( "front:%i back:%i\n", frontEnd, backEnd );
|
|
|
|
//glPopAttrib();
|
|
//DrawEntityData();
|
|
|
|
//wglSwapBuffers(dc.m_hDC);
|
|
// get back to the editor state
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
Cam_BuildMatrix();
|
|
}
|
|
|
|
|
|
void CCamWnd::OnTimer(UINT_PTR nIDEvent)
|
|
{
|
|
if (animationMode || nIDEvent == 1) {
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
}
|
|
if (nIDEvent == 1) {
|
|
KillTimer(1);
|
|
}
|
|
|
|
if (!animationMode) {
|
|
KillTimer(0);
|
|
}
|
|
}
|
|
|
|
|
|
void CCamWnd::UpdateCameraView() {
|
|
if (QE_SingleBrush(true, true)) {
|
|
brush_t* b = selected_brushes.next;
|
|
if (b->owner->eclass->nShowFlags & ECLASS_CAMERAVIEW) {
|
|
// find the entity that targets this
|
|
const char* name = ValueForKey(b->owner, "name");
|
|
entity_t* ent = FindEntity("target", name);
|
|
if (ent) {
|
|
if (!saveValid) {
|
|
saveOrg = m_Camera.origin;
|
|
saveAng = m_Camera.angles;
|
|
saveValid = true;
|
|
}
|
|
idVec3 v = b->owner->origin - ent->origin;
|
|
v.Normalize();
|
|
idAngles ang = v.ToMat3().ToAngles();
|
|
ang.pitch = -ang.pitch;
|
|
ang.roll = 0.0f;
|
|
SetView(ent->origin, ang);
|
|
Cam_BuildMatrix();
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (saveValid) {
|
|
SetView(saveOrg, saveAng);
|
|
Cam_BuildMatrix();
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
saveValid = false;
|
|
}
|
|
}
|
|
|