384 lines
10 KiB
C++
384 lines
10 KiB
C++
|
/*
|
||
|
|
** 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/>.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/***********************************************************************************************
|
||
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
||
|
|
***********************************************************************************************
|
||
|
|
* *
|
||
|
|
* Project Name : W3DView *
|
||
|
|
* *
|
||
|
|
* $Archive:: /Commando/Code/Tools/W3DView/ScreenCursor.cpp $Modtime:: $*
|
||
|
|
* *
|
||
|
|
* $Revision:: 8 $*
|
||
|
|
* *
|
||
|
|
*---------------------------------------------------------------------------------------------*
|
||
|
|
* Functions: *
|
||
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||
|
|
|
||
|
|
|
||
|
|
#include "StdAfx.H"
|
||
|
|
#include "ScreenCursor.H"
|
||
|
|
#include "Utils.H"
|
||
|
|
#include "ww3d.h"
|
||
|
|
#include "vertmaterial.h"
|
||
|
|
#include "shader.h"
|
||
|
|
#include "scene.h"
|
||
|
|
#include "rinfo.h"
|
||
|
|
#include "texture.h"
|
||
|
|
#include "dx8wrapper.h"
|
||
|
|
#include "dx8vertexbuffer.h"
|
||
|
|
#include "dx8indexbuffer.h"
|
||
|
|
#include "sortingrenderer.h"
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// ScreenCursorClass
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
ScreenCursorClass::ScreenCursorClass (void)
|
||
|
|
: m_ScreenPos (0, 0),
|
||
|
|
m_pTexture (NULL),
|
||
|
|
m_pVertMaterial (NULL),
|
||
|
|
m_Width (0),
|
||
|
|
m_Height (0),
|
||
|
|
m_hWnd (NULL)
|
||
|
|
{
|
||
|
|
Initialize ();
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// ScreenCursorClass
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
ScreenCursorClass::ScreenCursorClass (const ScreenCursorClass &src)
|
||
|
|
: m_ScreenPos (0, 0),
|
||
|
|
m_pTexture (NULL),
|
||
|
|
m_hWnd (NULL),
|
||
|
|
m_pVertMaterial (NULL),
|
||
|
|
m_Width (0),
|
||
|
|
m_Height (0),
|
||
|
|
RenderObjClass (src)
|
||
|
|
{
|
||
|
|
Initialize ();
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// ~ScreenCursorClass
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
ScreenCursorClass::~ScreenCursorClass (void)
|
||
|
|
{
|
||
|
|
REF_PTR_RELEASE (m_pTexture);
|
||
|
|
REF_PTR_RELEASE (m_pVertMaterial);
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Initialize
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Initialize (void)
|
||
|
|
{
|
||
|
|
REF_PTR_RELEASE(m_pVertMaterial);
|
||
|
|
|
||
|
|
// Create default vertex material
|
||
|
|
m_pVertMaterial = NEW_REF( VertexMaterialClass, ());
|
||
|
|
m_pVertMaterial->Set_Diffuse (1.0F, 1.0F, 1.0F);
|
||
|
|
m_pVertMaterial->Set_Emissive (0.0F, 0.0F, 0.0F);
|
||
|
|
m_pVertMaterial->Set_Specular (1.0F, 1.0F, 1.0F);
|
||
|
|
m_pVertMaterial->Set_Ambient (1.0F, 1.0F, 1.0F);
|
||
|
|
|
||
|
|
m_Triangles[0].I = 0;
|
||
|
|
m_Triangles[0].J = 1;
|
||
|
|
m_Triangles[0].K = 2;
|
||
|
|
m_Triangles[1].I = 1;
|
||
|
|
m_Triangles[1].J = 2;
|
||
|
|
m_Triangles[1].K = 3;
|
||
|
|
|
||
|
|
m_Normals[0].X = 0;
|
||
|
|
m_Normals[0].Y = 0;
|
||
|
|
m_Normals[0].Z = -1;
|
||
|
|
m_Normals[1].X = 0;
|
||
|
|
m_Normals[1].Y = 0;
|
||
|
|
m_Normals[1].Z = -1;
|
||
|
|
m_Normals[2].X = 0;
|
||
|
|
m_Normals[2].Y = 0;
|
||
|
|
m_Normals[2].Z = -1;
|
||
|
|
m_Normals[3].X = 0;
|
||
|
|
m_Normals[3].Y = 0;
|
||
|
|
m_Normals[3].Z = -1;
|
||
|
|
|
||
|
|
m_UVs[0].X = 0;
|
||
|
|
m_UVs[0].Y = 0;
|
||
|
|
m_UVs[1].X = 1.0F;
|
||
|
|
m_UVs[1].Y = 0;
|
||
|
|
m_UVs[2].X = 0;
|
||
|
|
m_UVs[2].Y = 1.0F;
|
||
|
|
m_UVs[3].X = 1.0F;
|
||
|
|
m_UVs[3].Y = 1.0F;
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Set_Texture
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Set_Texture (TextureClass *texture)
|
||
|
|
{
|
||
|
|
MEMBER_ADD (m_pTexture, texture);
|
||
|
|
|
||
|
|
// Find the dimensions of the texture:
|
||
|
|
if (m_pTexture != NULL) {
|
||
|
|
m_Width = m_pTexture->Get_Width();
|
||
|
|
m_Height = m_pTexture->Get_Height();
|
||
|
|
}
|
||
|
|
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// On_Frame_Update
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::On_Frame_Update (void)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Get the current cursor position in screen coords
|
||
|
|
//
|
||
|
|
POINT point = { 0 };
|
||
|
|
::GetCursorPos (&point);
|
||
|
|
|
||
|
|
if (m_hWnd != NULL) {
|
||
|
|
|
||
|
|
//
|
||
|
|
// Normalize the screen position
|
||
|
|
//
|
||
|
|
RECT rect = { 0 };
|
||
|
|
::GetClientRect (m_hWnd, &rect);
|
||
|
|
::ScreenToClient (m_hWnd, &point);
|
||
|
|
m_ScreenPos.X = ((float)point.x) / ((float)rect.right);
|
||
|
|
m_ScreenPos.Y = ((float)point.y) / ((float)rect.bottom);
|
||
|
|
|
||
|
|
} else {
|
||
|
|
|
||
|
|
//
|
||
|
|
// Normalize the screen position
|
||
|
|
//
|
||
|
|
m_ScreenPos.X = ((float)point.x) / ((float)::GetSystemMetrics (SM_CXSCREEN));
|
||
|
|
m_ScreenPos.Y = ((float)point.y) / ((float)::GetSystemMetrics (SM_CYSCREEN));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Determine the current display resolution
|
||
|
|
//
|
||
|
|
int screen_cx = 0;
|
||
|
|
int screen_cy = 0;
|
||
|
|
int bits = 0;
|
||
|
|
bool windowed = false;
|
||
|
|
WW3D::Get_Device_Resolution (screen_cx, screen_cy, bits, windowed);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Calculate the 3D position
|
||
|
|
//
|
||
|
|
float normal_width = ((float)m_Width) / (float)screen_cx;
|
||
|
|
float normal_height = ((float)m_Height) / (float)screen_cy;
|
||
|
|
float x_pos = floor(m_ScreenPos.X * ((float)screen_cx) + 0.5F) / ((float)screen_cx);
|
||
|
|
float y_pos = floor(m_ScreenPos.Y * ((float)screen_cy) + 0.5F) / ((float)screen_cy);
|
||
|
|
float z_pos = 0;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Convert the 3D position to normalized 'view' coords
|
||
|
|
//
|
||
|
|
float x_max = ((x_pos + normal_width) * 2) - 1;
|
||
|
|
float y_max = 1 - ((y_pos + normal_height) * 2);
|
||
|
|
x_pos = (x_pos * 2) - 1;
|
||
|
|
y_pos = 1 - (y_pos * 2);
|
||
|
|
z_pos = 0;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Build the verticies from the position and extents
|
||
|
|
//
|
||
|
|
m_Verticies[0].X = x_pos;
|
||
|
|
m_Verticies[0].Y = y_pos;
|
||
|
|
m_Verticies[0].Z = z_pos;
|
||
|
|
|
||
|
|
m_Verticies[1].X = x_max;
|
||
|
|
m_Verticies[1].Y = y_pos;
|
||
|
|
m_Verticies[1].Z = z_pos;
|
||
|
|
|
||
|
|
m_Verticies[2].X = x_pos;
|
||
|
|
m_Verticies[2].Y = y_max;
|
||
|
|
m_Verticies[2].Z = z_pos;
|
||
|
|
|
||
|
|
m_Verticies[3].X = x_max;
|
||
|
|
m_Verticies[3].Y = y_max;
|
||
|
|
m_Verticies[3].Z = z_pos;
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Render
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Render (RenderInfoClass &rinfo)
|
||
|
|
{
|
||
|
|
const int VERTEX_COUNT = 4;
|
||
|
|
const int FACE_COUNT = 2;
|
||
|
|
/*
|
||
|
|
** Dump the vertices into the dynamic sorting vertex buffer.
|
||
|
|
*/
|
||
|
|
DynamicVBAccessClass vbaccess(BUFFER_TYPE_DYNAMIC_SORTING,dynamic_fvf_type,VERTEX_COUNT);
|
||
|
|
{
|
||
|
|
DynamicVBAccessClass::WriteLockClass lock(&vbaccess);
|
||
|
|
VertexFormatXYZNDUV2* vb=lock.Get_Formatted_Vertex_Array();
|
||
|
|
|
||
|
|
for (int i=0; i<VERTEX_COUNT; i++) {
|
||
|
|
|
||
|
|
// Locations
|
||
|
|
vb->x=m_Verticies[i].X;
|
||
|
|
vb->y=m_Verticies[i].Y;
|
||
|
|
vb->z=m_Verticies[i].Z;
|
||
|
|
|
||
|
|
// Normals
|
||
|
|
vb->nx=m_Normals[i].X;
|
||
|
|
vb->ny=m_Normals[i].Y;
|
||
|
|
vb->nz=m_Normals[i].Z;
|
||
|
|
|
||
|
|
// UV coordinates
|
||
|
|
vb->u1=m_UVs[i].X;
|
||
|
|
vb->v1=m_UVs[i].Y;
|
||
|
|
|
||
|
|
vb++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
** Dump the faces into the dynamic sorting index buffer.
|
||
|
|
*/
|
||
|
|
DynamicIBAccessClass ibaccess(BUFFER_TYPE_DYNAMIC_SORTING,FACE_COUNT*3);
|
||
|
|
{
|
||
|
|
DynamicIBAccessClass::WriteLockClass lock(&ibaccess);
|
||
|
|
unsigned short * indices = lock.Get_Index_Array();
|
||
|
|
for (int i=0; i<FACE_COUNT; i++) {
|
||
|
|
indices[3*i+0] = m_Triangles[i][0];
|
||
|
|
indices[3*i+1] = m_Triangles[i][1];
|
||
|
|
indices[3*i+2] = m_Triangles[i][2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
** Apply the shader and material
|
||
|
|
*/
|
||
|
|
DX8Wrapper::Set_Material(m_pVertMaterial);
|
||
|
|
DX8Wrapper::Set_Shader(ShaderClass::_PresetATestBlend2DShader);
|
||
|
|
DX8Wrapper::Set_Texture(0,m_pTexture);
|
||
|
|
|
||
|
|
DX8Wrapper::Set_Vertex_Buffer(vbaccess);
|
||
|
|
DX8Wrapper::Set_Index_Buffer(ibaccess,0);
|
||
|
|
|
||
|
|
SphereClass sphere;
|
||
|
|
Get_Obj_Space_Bounding_Sphere(sphere);
|
||
|
|
|
||
|
|
SortingRendererClass::Insert_Triangles(
|
||
|
|
sphere,
|
||
|
|
0,
|
||
|
|
FACE_COUNT*3,
|
||
|
|
0,
|
||
|
|
VERTEX_COUNT*2);
|
||
|
|
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Get_Obj_Space_Bounding_Sphere
|
||
|
|
//
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Get_Obj_Space_Bounding_Sphere(SphereClass & sphere) const
|
||
|
|
{
|
||
|
|
sphere.Center = Get_Transform().Get_Translation();
|
||
|
|
sphere.Radius = max (m_Width, m_Height);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Get_Obj_Space_Bounding_Box
|
||
|
|
//
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Get_Obj_Space_Bounding_Box(AABoxClass & box) const
|
||
|
|
{
|
||
|
|
Matrix3D transform = Get_Transform ();
|
||
|
|
box.Center = transform.Get_Translation ();
|
||
|
|
box.Extent.Set(0.1F, m_Width, m_Height);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Notify_Added
|
||
|
|
//
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Notify_Added (SceneClass * scene)
|
||
|
|
{
|
||
|
|
if (scene != NULL) {
|
||
|
|
scene->Register (this, SceneClass::ON_FRAME_UPDATE);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Notify_Removed
|
||
|
|
//
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
void
|
||
|
|
ScreenCursorClass::Notify_Removed (SceneClass * scene)
|
||
|
|
{
|
||
|
|
if (scene != NULL) {
|
||
|
|
scene->Unregister (this, SceneClass::ON_FRAME_UPDATE);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ;
|
||
|
|
}
|