This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Tests/SplineTest/SplineTestDoc.cpp

280 lines
5.5 KiB
C++
Raw Permalink Normal View History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program 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.
**
** This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
// SplineTestDoc.cpp : implementation of the CSplineTestDoc class
//
#include "stdafx.h"
#include "SplineTest.h"
#include "SplineTestDoc.h"
#include "CurvePoints.h"
#include "curve.h"
#include "hermitespline.h"
#include "catmullromspline.h"
#include "cardinalspline.h"
#include "tcbspline.h"
#include "wwmath.h"
#include "CardinalDialog.h"
#include "TCBDialog.h"
#include "Matrix3D.h"
#include "vehiclecurve.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
const float GRAB_DIST = 0.25f;
/////////////////////////////////////////////////////////////////////////////
// CSplineTestDoc
IMPLEMENT_DYNCREATE(CSplineTestDoc, CDocument)
BEGIN_MESSAGE_MAP(CSplineTestDoc, CDocument)
//{{AFX_MSG_MAP(CSplineTestDoc)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CSplineTestDoc construction/destruction
CSplineTestDoc::CSplineTestDoc()
{
CurveType = LINEAR;
Curve = new LinearCurve3DClass;
DragIndex = -1;
}
CSplineTestDoc::~CSplineTestDoc()
{
if (Curve != NULL) {
delete Curve;
}
}
BOOL CSplineTestDoc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return FALSE;
// TODO: add reinitialization code here
// (SDI documents will reuse this document)
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CSplineTestDoc serialization
void CSplineTestDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// TODO: add storing code here
}
else
{
// TODO: add loading code here
}
}
/////////////////////////////////////////////////////////////////////////////
// CSplineTestDoc diagnostics
#ifdef _DEBUG
void CSplineTestDoc::AssertValid() const
{
CDocument::AssertValid();
}
void CSplineTestDoc::Dump(CDumpContext& dc) const
{
CDocument::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CSplineTestDoc commands
void CSplineTestDoc::Reset_Curve(void)
{
if (Curve != NULL) {
delete Curve;
}
Curve = Create_Curve(CurveType);
DragIndex = -1;
UpdateAllViews(NULL);
}
void CSplineTestDoc::Set_Curve_Type(int type)
{
assert (Curve != NULL);
if (type != CurveType) {
Curve3DClass * new_curve = NULL;
new_curve = Create_Curve(type);
for (int i=0; i<Curve->Key_Count(); i++) {
Vector3 pt;
float t;
Curve->Get_Key(i,&pt,&t);
new_curve->Add_Key(pt,t);
UpdateAllViews(NULL);
}
delete Curve;
Curve = new_curve;
CurveType = type;
}
}
int CSplineTestDoc::Get_Curve_Type(void)
{
return CurveType;
}
Curve3DClass * CSplineTestDoc::Get_Curve(void)
{
return Curve;
}
Curve3DClass * CSplineTestDoc::Create_Curve(int type)
{
Curve3DClass * new_curve = NULL;
switch (type) {
case LINEAR:
new_curve = new LinearCurve3DClass;
break;
case VEHICLE:
new_curve = new VehicleCurveClass (1.0F);
break;
case CATMULL_ROM:
new_curve = new CatmullRomSpline3DClass;
break;
case CARDINAL:
new_curve = new CardinalSpline3DClass;
break;
case TCB:
new_curve = new TCBSpline3DClass;
break;
}
return new_curve;
}
bool CSplineTestDoc::Grab_Point(const Vector3 & pos)
{
DragIndex = -1;
if (Curve) {
DragIndex = Pick(pos);
}
return (DragIndex != -1);
}
bool CSplineTestDoc::Drag_Point(const Vector3 & pos)
{
if (DragIndex == -1) {
return false;
} else {
if (Curve) {
Curve->Set_Key(DragIndex,pos);
UpdateAllViews(NULL);
}
return true;
}
}
bool CSplineTestDoc::Release_Point(void)
{
DragIndex = -1;
return true;
}
bool CSplineTestDoc::Is_Dragging(void)
{
return (DragIndex != -1);
}
bool CSplineTestDoc::Add_Point(const Vector3 & pos)
{
if (Curve == NULL) return false;
if (Curve->Key_Count() == 0) {
Curve->Add_Key(pos,0.0f);
} else {
// make dt random for testing
Curve->Add_Key(pos,Curve->Get_End_Time() + 1.0f); //WWMath::Random_Float(0.1f,5.0f));
}
UpdateAllViews(NULL);
return true;
}
int CSplineTestDoc::Pick(const Vector3 & pos)
{
int index = -1;
for (int pi=0; pi<Curve->Key_Count(); pi++) {
Vector3 keypt;
Curve->Get_Key(pi,&keypt,NULL);
if ((keypt - pos).Length() < GRAB_DIST) {
index = pi;
break;
}
}
return index;
}
void CSplineTestDoc::Edit_Point(const Vector3 & pos)
{
int index = Pick(pos);
if (index == -1) return;
switch (CurveType) {
case LINEAR:
case CATMULL_ROM:
case VEHICLE:
break;
case CARDINAL:
{
CCardinalDialog dlg(::AfxGetMainWnd(),(CardinalSpline3DClass *)Curve,index);
dlg.DoModal();
break;
}
case TCB:
{
CTCBDialog dlg(::AfxGetMainWnd(),(TCBSpline3DClass *)Curve,index);
dlg.DoModal();
break;
}
}
UpdateAllViews(NULL);
return;
}
void CSplineTestDoc::Simulate_Turn_Radius (void)
{
return ;
}