tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
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/skeleton_gth/skeleton_gth.cpp

1179 lines
34 KiB
C++
Raw Permalink Blame 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/>.
*/
//
// skeleton.cpp : Defines the entry point for the application.
//
// Skeleton WW3D code, Hector Yee, 8/31/00
#include "resource.h"
#include "wwmath.h"
#include "ww3d.h"
#include "scene.h"
#include "rendobj.h"
#include "camera.h"
#include "AssetMgr.H"
#include "msgloop.h"
#include "part_ldr.h"
#include "rendobj.h"
#include "hanim.h"
#include "dx8wrapper.h"
#include "dx8indexbuffer.h"
#include "dx8vertexbuffer.h"
#include "dx8fvf.h"
#include "vertmaterial.h"
#include "font3d.h"
#include "render2d.h"
#include "textdraw.h"
#include "rect.h"
#include "mesh.h"
#include "meshmdl.h"
#include "line3d.h"
#include "dynamesh.h"
#include "sphereobj.h"
#include "ringobj.h"
#include "surfaceclass.h"
#include "vector2i.h"
#include "bmp2d.h"
#include "decalsys.h"
#include "shattersystem.h"
#include "light.h"
#include "texproject.h"
#include "keyboard.h"
#include "wwmouse.h"
#include "predlod.h"
#include "segline.h"
#include <stdio.h>
#include "dx8renderer.h"
#include "textureloader.h"
#define MAX_LOADSTRING 100
const int RESOLUTION_X = 640;
const int RESOLUTION_Y = 480;
const int BIT_DEPTH = 16;
const Vector3 CAMERA_POSITION(3.0f,0.0f,1.0f);
const Vector3 CAMERA_TARGET(0.0f,0.0f,0.90f);
const Vector3 OBJECT_POSITION(0.0f,0.0f,0.0f);
const char * OBJECT_NAME = "area1-LM";
const char * ANIM_NAME = NULL;
static void Log_Statistics();
static void Init_Assets();
static void Init_3D_Scene();
static void Init_2D_Scene();
class SkeletonSceneClass;
// Global Variables:
HINSTANCE hInst; // current instance
TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING]; // The title bar text
WW3DAssetManager * AssetManager=NULL;
SkeletonSceneClass * my_scene = NULL;
SimpleSceneClass * my_2d_scene = NULL;
CameraClass * my_camera = NULL;
CameraClass * my_2d_camera = NULL;
Render2DTextClass * mytext = NULL;
RenderObjClass * my_object = NULL;
HAnimClass * my_anim = NULL;
TexProjectClass * my_texture_projector = NULL;
MaterialPassClass * my_material_pass = NULL;
LightClass * my_lights[3];
Font3DInstanceClass *my_font_a=NULL;
Font3DInstanceClass *my_font_b=NULL;
DecalSystemClass TheDecalSystem;
bool running=true;
bool rotate=true;
bool randmat=false;
bool randtex=false;
bool staticsort=true;
bool using_mat_pass=false;
int shatter=0;
// Foward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
void Enable_Alternate_Materials(RenderObjClass * model,bool onoff);
void Render();
void Render2();
RenderObjClass * Create_Dynamesh(void);
RenderObjClass * Create_Sphere(void);
RenderObjClass * Create_Ring(void);
RenderObjClass * Create_bitmap2d(void);
RenderObjClass * Create_segline(void);
void WWDebug_Message_Callback(DebugType type, const char * message);
void WWAssert_Callback(const char * message);
void Debug_Refs(void);
void Create_Decal(RenderObjClass * obj,Matrix3D & tm,float radius,char * texture);
MaterialPassClass * Create_Material_Pass(void);
TexProjectClass * Create_Texture_Projector(void);
// ----------------------------------------------------------------------------
//
// FPS counter class counts how many times Update() has been called during the
// last second. The fps counter caps at MAX_FPS which is the maximum fps count
// that can be measured.
//
// ----------------------------------------------------------------------------
const unsigned MAX_FPS=2000;
class FPSCounterClass
{
unsigned frame_times[MAX_FPS];
unsigned frame_time_count;
public:
FPSCounterClass();
void Update();
unsigned Get_FPS();
};
static FPSCounterClass fps_counter;
// ----------------------------------------------------------------------------
FPSCounterClass::FPSCounterClass()
:
frame_time_count(0)
{
}
// ----------------------------------------------------------------------------
void FPSCounterClass::Update()
{
unsigned frame_time=timeGetTime();
unsigned limit=frame_time-1000;
for (unsigned i=0;i<frame_time_count;++i) {
if (frame_times[i]<limit) {
frame_times[i]=frame_times[frame_time_count-1];
frame_time_count--;
}
}
if (frame_time_count<MAX_FPS) {
frame_times[frame_time_count++]=frame_time;
}
}
// ----------------------------------------------------------------------------
unsigned FPSCounterClass::Get_FPS()
{
return frame_time_count;
}
// ----------------------------------------------------------------------------
//
// Cusomized scene for testing material passes.
//
// ----------------------------------------------------------------------------
class SkeletonSceneClass : public SimpleSceneClass
{
public:
SkeletonSceneClass(void) : TestPass(NULL) { }
~SkeletonSceneClass(void) { REF_PTR_RELEASE(TestPass); }
virtual void Customized_Render(RenderInfoClass & rinfo);
void Set_Material_Pass(MaterialPassClass * pass) { REF_PTR_SET(TestPass,pass); }
protected:
MaterialPassClass * TestPass;
};
// ----------------------------------------------------------------------------
void SkeletonSceneClass::Customized_Render(RenderInfoClass & rinfo)
{
if (TestPass) {
rinfo.Push_Material_Pass(TestPass);
}
SimpleSceneClass::Customized_Render(rinfo);
if (TestPass) {
rinfo.Pop_Material_Pass();
}
}
// ----------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
HACCEL hAccelTable;
hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_SKELETON);
// install debug callbacks
WWDebug_Install_Message_Handler(WWDebug_Message_Callback);
WWDebug_Install_Assert_Handler(WWAssert_Callback);
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_SKELETON, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
hInst = hInstance; // Store instance handle in our global variable
HWND hWnd = CreateWindow(
szWindowClass,
szTitle,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
CW_USEDEFAULT,
0,
NULL,
NULL,
hInstance,
NULL);
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
// WW Inits
WWMath::Init ();
AssetManager=new WW3DAssetManager;
AssetManager->Register_Prototype_Loader(&_ParticleEmitterLoader);
AssetManager->Load_3D_Assets("ShatterPlanes0.w3d"); // Shatter planes
WW3D::Init(hWnd);
// WW3D::Set_Prelit_Mode(WW3D::PRELIT_MODE_VERTEX);
WW3D::Set_Prelit_Mode(WW3D::PRELIT_MODE_LIGHTMAP_MULTI_PASS);
// WW3D::Set_Prelit_Mode(WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE);
// WW3D::Set_Collision_Box_Display_Mask(0xFF);
if (WW3D::Set_Render_Device(-1,RESOLUTION_X,RESOLUTION_Y,BIT_DEPTH,1,true)!=WW3D_ERROR_OK) {
if (WW3D::Set_Any_Render_Device()!=WW3D_ERROR_OK) {
WW3D::Shutdown();
WWMath::Shutdown ();
Debug_Refs();
return 0;
}
}
Init_Assets();
Init_2D_Scene();
Init_3D_Scene();
// main loop
int time=timeGetTime();
float theta = 0.0f;
while (running)
{
if (my_object && rotate) {
theta += DEG_TO_RADF(0.1f);
Matrix3D tm(1);
tm.Rotate_Z(theta);
//tm.Rotate_X(theta*1.37f);
//tm.Rotate_Y(theta*1.09f);
tm.Set_Translation(OBJECT_POSITION);
my_object->Set_Transform(tm);
}
if (my_object && my_texture_projector) {
my_texture_projector->Set_Transform(my_object->Get_Bone_Transform("ProjectorBone"));
}
if (shatter==1)
{
if (my_object->Class_ID()==RenderObjClass::CLASSID_MESH)
{
my_scene->Remove_Render_Object(my_object);
ShatterSystem::Shatter_Mesh((MeshClass*)my_object,Vector3(0,0,0),Vector3(1,0,0));
REF_PTR_RELEASE(my_object);
int count=ShatterSystem::Get_Fragment_Count();
int i;
for (i=0; i<count; i++)
{
my_object=ShatterSystem::Get_Fragment(i);
my_object->Set_Position(my_object->Get_Position()+Vector3(rand()%15,rand()%15,rand()%15));
my_scene->Add_Render_Object(my_object);
REF_PTR_RELEASE(my_object);
}
}
shatter++;
}
if (randmat)
{
if (my_object->Class_ID()==RenderObjClass::CLASSID_MESH)
{
MeshClass *mesh=(MeshClass*) my_object;
MaterialInfoClass *mi=mesh->Get_Material_Info();
VertexMaterialClass *vm=mi->Get_Vertex_Material(0);
VertexMaterialClass *newvm=NEW_REF(VertexMaterialClass,(*vm));
newvm->Set_Emissive(rand()%256/256.0,rand()%256/256.0,rand()%256/256.0);
mesh->Replace_VertexMaterial(vm,newvm);
mi->Replace_Material(0,newvm);
REF_PTR_RELEASE(vm);
REF_PTR_RELEASE(newvm);
}
randmat=!randmat;
}
if (randtex)
{
if (my_object->Class_ID()==RenderObjClass::CLASSID_MESH)
{
MeshClass *mesh=(MeshClass*) my_object;
MaterialInfoClass *mi=mesh->Get_Material_Info();
TextureClass *tex=mi->Peek_Texture(0);
int ran=rand() % 3;
char name[100];
switch (ran)
{
case 0: sprintf(name,"catwalk.tga");
break;
case 1: sprintf(name,"chickonmap.tga");
break;
case 2: sprintf(name,"fullmoon.tga");
break;
}
TextureClass *newtex=AssetManager->Get_Texture(name);
mesh->Replace_Texture(tex,newtex);
mi->Replace_Texture(0,newtex);
REF_PTR_RELEASE(newtex);
}
randtex=!randtex;
}
if (my_texture_projector != NULL) {
my_texture_projector->Pre_Render_Update(my_camera->Get_Transform());
}
WW3D::Enable_Static_Sort_Lists(staticsort);
Render();
Windows_Message_Handler();
WW3D::Sync(timeGetTime()-time);
Log_Statistics();
}
REF_PTR_RELEASE(my_scene);
REF_PTR_RELEASE(my_camera);
REF_PTR_RELEASE(my_2d_scene);
REF_PTR_RELEASE(my_2d_camera);
REF_PTR_RELEASE(my_lights[0]);
REF_PTR_RELEASE(my_lights[1]);
REF_PTR_RELEASE(my_lights[2]);
delete mytext;
REF_PTR_RELEASE(my_font_a);
REF_PTR_RELEASE(my_font_b);
REF_PTR_RELEASE(my_object);
REF_PTR_RELEASE(my_anim);
REF_PTR_RELEASE(my_material_pass);
REF_PTR_RELEASE(my_texture_projector);
PredictiveLODOptimizerClass::Free();
// shutdown
AssetManager->Free_Assets ();
delete AssetManager;
WW3D::Shutdown ();
WWMath::Shutdown ();
Debug_Refs();
return 0;
}
// ----------------------------------------------------------------------------
//
// Render everything. Rendering stars with Begin_Scene() and ends to End_Scene().
//
// ----------------------------------------------------------------------------
void Render()
{
// Predictive LOD optimizer optimizes the mesh LOD levels to match the given polygon budget
PredictiveLODOptimizerClass::Optimize_LODs(5000);
WW3D::Begin_Render(true,true,Vector3(0.0f,0.0f,0.0f));
// Render 3D scene
WW3D::Render(my_scene,my_camera);
// Render 2D scene
WW3D::Render(my_2d_scene,my_2d_camera);
if (mytext) mytext->Render();
WW3D::End_Render();
fps_counter.Update();
}
// ----------------------------------------------------------------------------
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
// COMMENTS:
//
// This function and its usage is only necessary if you want this code
// to be compatible with Win32 systems prior to the 'RegisterClassEx'
// function that was added to Windows 95. It is important to call this function
// so that the application will get 'well formed' small icons associated
// with it.
//
// ----------------------------------------------------------------------------
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_SKELETON);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = (LPCSTR)IDC_SKELETON;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
return RegisterClassEx(&wcex);
}
// ----------------------------------------------------------------------------
//
// FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
// ----------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_ACTIVATEAPP:
if (wParam) WW3D::On_Activate_App();
else WW3D::On_Deactivate_App();
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code here...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
running=false;
PostQuitMessage(0);
break;
case WM_KEYUP:
if ((wParam&0xff)==VK_ESCAPE) {
DestroyWindow(hWnd);
return 0;
}
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_CHAR:
{
char key=LOWORD(wParam);
switch (key)
{
case ' ':
shatter++;
break;
case '-':
WW3D::Make_Screen_Shot("screen");
break;
case '+':
WW3D::Toggle_Movie_Capture();
break;
case 'r':
rotate=!rotate;
break;
case '1':
WW3D::Set_NPatches_Level(1);
break;
case '2':
WW3D::Set_NPatches_Level(2);
break;
case '3':
WW3D::Set_NPatches_Level(3);
break;
case '4':
WW3D::Set_NPatches_Level(4);
break;
case '5':
WW3D::Set_NPatches_Level(5);
break;
case '6':
WW3D::Set_NPatches_Level(6);
break;
case '7':
WW3D::Set_NPatches_Level(7);
break;
case '8':
WW3D::Set_NPatches_Level(8);
break;
case 'q':
randmat=!randmat;
break;
case 'w':
randtex=!randtex;
break;
case 's':
staticsort=!staticsort;
break;
case 'b':
{
using_mat_pass=!using_mat_pass;
if (!using_mat_pass) {
my_scene->Set_Material_Pass(0);
}
else {
my_scene->Set_Material_Pass(my_material_pass);
}
}
break;
case 'g':
{
if (WW3D::Get_NPatches_Gap_Filling_Mode()==WW3D::NPATCHES_GAP_FILLING_DISABLED) {
WW3D::Set_NPatches_Gap_Filling_Mode(WW3D::NPATCHES_GAP_FILLING_ENABLED);
}
else {
WW3D::Set_NPatches_Gap_Filling_Mode(WW3D::NPATCHES_GAP_FILLING_DISABLED);
}
}
break;
case 'm':
{
SceneClass::PolyRenderType type = my_scene->Get_Polygon_Mode();
type = (type == SceneClass::POINT) ? SceneClass::LINE : ((type == SceneClass::LINE) ? SceneClass::FILL : SceneClass::POINT);
my_scene->Set_Polygon_Mode(type);
}
break;
}
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Mesage handler for about box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
break;
}
return FALSE;
}
void Enable_Alternate_Materials(RenderObjClass * model,bool onoff)
{
if (model == NULL) return;
for (int i=0; i<model->Get_Num_Sub_Objects(); i++) {
RenderObjClass * subobj = model->Get_Sub_Object(i);
Enable_Alternate_Materials(subobj,onoff);
REF_PTR_RELEASE(subobj);
}
if (model->Class_ID() == RenderObjClass::CLASSID_MESH) {
MeshModelClass * mesh_model = ((MeshClass *)model)->Get_Model();
mesh_model->Enable_Alternate_Material_Description(onoff);
REF_PTR_RELEASE(mesh_model);
}
}
// ----------------------------------------------------------------------------
//
// WWDebug message callback defines the behavior of WWDEBUG_SAY().
//
// ----------------------------------------------------------------------------
void WWDebug_Message_Callback(DebugType type, const char * message)
{
OutputDebugString(message);
}
// ----------------------------------------------------------------------------
//
// WWAssert callback defines the behavior of WWASSERT().
//
// ----------------------------------------------------------------------------
void WWAssert_Callback(const char * message)
{
OutputDebugString(message);
_asm int 0x03
}
// ----------------------------------------------------------------------------
RenderObjClass * Create_Dynamesh(void)
{
// Create a tetrahedron
DynamicMeshClass *dynamesh = NEW_REF(DynamicMeshClass, (4, 6));
dynamesh->Set_Shader(ShaderClass::_PresetOpaqueShader);
VertexMaterialClass *vm = VertexMaterialClass::Get_Preset(VertexMaterialClass::PRELIT_NODIFFUSE);
dynamesh->Set_Vertex_Material(vm);
vm->Release_Ref();
TextureClass *texture = AssetManager->Get_Texture("chickonmap.tga");
dynamesh->Set_Texture(texture);
texture->Release_Ref();
dynamesh->Vertex(0.0f, 100.0f, 0.0f, 1.0f, 0.0f);
dynamesh->Vertex(100.0f, -100.0f, 0.0f ,1.0f, -1.0f);
dynamesh->Vertex(-100.0f, -100.0f, 0.0f, -1.0f, -1.0f);
dynamesh->Vertex(0.0f, -100.0f, -100.0f, 0.0f, 0.0f);
dynamesh->Vertex(0.0f, 100.0f, 0.0f, 1.0f, 0.0f);
dynamesh->Vertex(100.0f, -100.0f, 0.0f ,1.0f, -1.0f);
return dynamesh;
}
RenderObjClass *Create_segline(void)
{
SegmentedLineClass *segline = NEW_REF(SegmentedLineClass,());
Vector3 locations[4];
locations[0].Set(0,0,0);
locations[1].Set(50,50,50);
locations[2].Set(50,-50,10);
locations[3].Set(-50,50,10);
segline->Set_Points(4, locations);
//segline->Set_Shader(ShaderClass::_PresetOpaqueShader);
segline->Set_Shader(ShaderClass::_PresetAlphaShader);
segline->Set_Color(Vector3(1,0,1));
segline->Set_Opacity(0.5);
segline->Set_Freeze_Random(1);
segline->Set_Visible(1);
segline->Set_Width(10);
TextureClass *tex=NEW_REF(TextureClass,("cloudlayer.tga"));
segline->Set_Texture(tex);
REF_PTR_RELEASE(tex);
// segline->Set_Texture_Mapping_Mode(SegmentedLineClass::TILED_TEXTURE_MAP);
segline->Set_Texture_Tile_Factor(5);
segline->Set_Noise_Amplitude(5);
segline->Set_Merge_Intersections(1);
return segline;
}
// ----------------------------------------------------------------------------
RenderObjClass * Create_Sphere(void)
{
SphereRenderObjClass *sph=NEW_REF(SphereRenderObjClass,());
sph->Set_Color(Vector3(1,0,1));
sph->Set_Scale(Vector3(100,100,100));
return sph;
}
// ----------------------------------------------------------------------------
RenderObjClass * Create_bitmap2d(void)
{
Bitmap2DObjClass *bmp=NEW_REF(Bitmap2DObjClass,("chickonmap.tga",0.0,0.0,false,false,false));
return bmp;
}
// ----------------------------------------------------------------------------
RenderObjClass * Create_Ring(void)
{
RingRenderObjClass *rng=NEW_REF(RingRenderObjClass,());
rng->Set_Color(Vector3(1,0,1));
rng->Set_Inner_Scale(Vector2(10,10));
rng->Set_Outer_Scale(Vector2(50,50));
return rng;
}
// ----------------------------------------------------------------------------
void Create_Decal(RenderObjClass * robj,Matrix3D & tm,float radius,char * texture_name)
{
/*
** Allocate the decal generator
*/
DecalGeneratorClass * gen = TheDecalSystem.Lock_Decal_Generator();
WWASSERT(gen != NULL);
/*
** Set up the transform, projection, and bounding volume parameters
*/
const float DECAL_HALF_SLAB_THICKNESS = 50.0f;
const float DECAL_BACKFACE_THRESHHOLD = 0.0f;
float backup_dist = DECAL_HALF_SLAB_THICKNESS + 0.01f;
Matrix3D transform = tm;
transform.Translate_Z(backup_dist);
gen->Set_Transform(transform);
gen->Set_Ortho_Projection(-radius,radius,-radius,radius,0.01f,backup_dist + 2.0f * DECAL_HALF_SLAB_THICKNESS);
gen->Set_Backface_Threshhold(DECAL_BACKFACE_THRESHHOLD);
/*
** Set up the material settings. Just plug in the standard alpha shader and the
** vertex material which all decals use. Then grab the texture which the user
** specified...
*/
MaterialPassClass * material = gen->Get_Material();
VertexMaterialClass * decal_mtl = NEW_REF(VertexMaterialClass,());
decal_mtl->Set_Ambient(0,0,0);
decal_mtl->Set_Diffuse(0,0,0);
decal_mtl->Set_Specular(0,0,0);
decal_mtl->Set_Emissive(1,1,1);
decal_mtl->Set_Opacity(1.0f);
decal_mtl->Set_Shininess(0.0f);
TextureClass * tex = WW3DAssetManager::Get_Instance()->Get_Texture(texture_name);
tex->Set_U_Addr_Mode(TextureClass::TEXTURE_ADDRESS_CLAMP);
tex->Set_V_Addr_Mode(TextureClass::TEXTURE_ADDRESS_CLAMP);
material->Set_Shader(ShaderClass::_PresetAlphaShader);
material->Set_Material(decal_mtl);
material->Set_Texture(tex);
REF_PTR_RELEASE(decal_mtl);
REF_PTR_RELEASE(tex);
REF_PTR_RELEASE(material);
/*
** Apply!
*/
robj->Create_Decal(gen);
TheDecalSystem.Unlock_Decal_Generator(gen);
}
// ----------------------------------------------------------------------------
MaterialPassClass * Create_Material_Pass(void)
{
TextureClass * texture = WW3DAssetManager::Get_Instance()->Get_Texture("decal.tga");
VertexMaterialClass * mtl = NEW_REF(VertexMaterialClass,());
mtl->Set_Diffuse(0.5f,0.5f,0.5f);
mtl->Set_Specular(0,0,0);
mtl->Set_Ambient(0,0,0);
mtl->Set_Emissive(0.5f,0.5f,0.5f);
mtl->Set_Lighting(false);
EnvironmentMapperClass * mapper = NEW_REF(EnvironmentMapperClass,(0));
mtl->Set_Mapper(mapper,0);
MaterialPassClass * test_pass = NEW_REF(MaterialPassClass,());
test_pass->Set_Shader(ShaderClass::_PresetAdditiveShader);
test_pass->Set_Material(mtl);
test_pass->Set_Texture(texture);
REF_PTR_RELEASE(mtl);
REF_PTR_RELEASE(texture);
REF_PTR_RELEASE(mapper);
return test_pass;
}
// ----------------------------------------------------------------------------
TexProjectClass * Create_Texture_Projector(void)
{
const float SIZE = 10.0f;
const float ZNEAR = 0.1f;
const float ZFAR = 300.0f;
TexProjectClass * new_projector = NEW_REF(TexProjectClass,());
new_projector->Init_Additive();
new_projector->Set_Intensity(1.0,true);
new_projector->Set_Ortho_Projection(-SIZE,SIZE,-SIZE,SIZE,ZNEAR,ZFAR);
Matrix3D tm;
tm.Look_At(Vector3(200,200,200),Vector3(0,0,0),0.0f);
new_projector->Set_Transform(tm);
TextureClass * texture = WW3DAssetManager::Get_Instance()->Get_Texture("GreenSpot.tga");
new_projector->Set_Texture(texture);
REF_PTR_RELEASE(texture);
return new_projector;
}
// ----------------------------------------------------------------------------
void Debug_Refs(void)
{
#ifdef _DEBUG
WWDEBUG_SAY(("Dumping Un-Released Ref-Counted objects...\r\n"));
RefCountNodeClass * first = RefCountClass::ActiveRefList.First();
RefCountNodeClass * node = first;
while (node->Is_Valid())
{
RefCountClass * obj = node->Get();
ActiveRefStruct * ref = &(obj->ActiveRefInfo);
bool display = true;
int count = 0;
RefCountNodeClass * search = first;
while (search->Is_Valid()) {
if (search == node) { // if this is not the first one
if (count != 0) {
display = false;
break;
}
}
RefCountClass * search_obj = search->Get();
ActiveRefStruct * search_ref = &(search_obj->ActiveRefInfo);
if ( ref->File && search_ref->File &&
!strcmp(search_ref->File, ref->File) &&
(search_ref->Line == ref->Line) ) {
count++;
} else if ( (ref->File == NULL) && (search_ref->File == NULL) ) {
count++;
}
search = search->Next();
}
if ( display ) {
WWDEBUG_SAY(( "%d Active Ref: %s %d %p\n", count, ref->File,ref->Line,obj));
static int num_printed = 0;
if (++num_printed > 20) {
WWDEBUG_SAY(( "And Many More......\n"));
break;
}
}
node = node->Next();
}
WWDEBUG_SAY(("Done.\r\n"));
#endif
}
// ----------------------------------------------------------------------
//
// Ugly statistics block!!!
//
// ----------------------------------------------------------------------
void Log_Statistics()
{
StringClass format(255,true);
StringClass status_text(500,true);
// static unsigned last_frame_time=0;
// unsigned frame_time=timeGetTime();
// unsigned time=frame_time-last_frame_time;
// last_frame_time=frame_time;
// if (time>1000) time=1000;
// float fps=1000.0f/float(time);
// static float time_fps;
// static float current_fps;
// static unsigned fps_count;
// time_fps+=fps;
// fps_count++;
// if (fps_count==20) {
// fps_count=0;
// current_fps=time_fps/20.0f;
// time_fps=0.0f;
// }
unsigned current_fps=fps_counter.Get_FPS();
static unsigned stats_mode;
static bool tab_pressed;
if (GetAsyncKeyState(VK_TAB)) {
if (!tab_pressed) {
stats_mode++;
stats_mode%=3;
}
tab_pressed=true;
}
else {
tab_pressed=false;
}
switch (stats_mode) {
case 0:
Debug_Statistics::Record_Texture_Mode(Debug_Statistics::RECORD_TEXTURE_NONE);
break;
case 1:
Debug_Statistics::Record_Texture_Mode(Debug_Statistics::RECORD_TEXTURE_NONE);
format.Format("%d FPS\n",current_fps);
status_text+=format;
format.Format("%d Polys/frame (%dk pps)\n",Debug_Statistics::Get_DX8_Polygons(),unsigned(Debug_Statistics::Get_DX8_Polygons()*float(current_fps))/1000);
status_text+=format;
break;
case 2:
Debug_Statistics::Record_Texture_Mode(Debug_Statistics::RECORD_TEXTURE_NONE);
format.Format("%d FPS\n",current_fps);
status_text+=format;
format.Format("%d Polys/frame (%dk pps)\n",Debug_Statistics::Get_DX8_Polygons(),unsigned(Debug_Statistics::Get_DX8_Polygons()*float(current_fps))/1000);
status_text+=format;
format.Format("%d Verts/frame (%dk vps)\n",Debug_Statistics::Get_DX8_Vertices(),unsigned(Debug_Statistics::Get_DX8_Vertices()*float(current_fps))/1000);
status_text+=format;
format.Format("%d DX8 calls\n",DX8Wrapper::Get_Last_Frame_DX8_Calls());
status_text+=format;
format.Format("%d VB changes\n",DX8Wrapper::Get_Last_Frame_Vertex_Buffer_Changes());
status_text+=format;
format.Format("%d IB changes\n",DX8Wrapper::Get_Last_Frame_Index_Buffer_Changes());
status_text+=format;
format.Format("%d texture changes\n",DX8Wrapper::Get_Last_Frame_Texture_Changes());
status_text+=format;
format.Format("%d material changes\n",DX8Wrapper::Get_Last_Frame_Material_Changes());
status_text+=format;
format.Format("%d light changes\n",DX8Wrapper::Get_Last_Frame_Light_Changes());
status_text+=format;
format.Format("%d RS changes\n",DX8Wrapper::Get_Last_Frame_Render_State_Changes());
status_text+=format;
format.Format("%d TSS changes\n",DX8Wrapper::Get_Last_Frame_Texture_Stage_State_Changes());
status_text+=format;
format.Format("%d Mtx changes\n",DX8Wrapper::Get_Last_Frame_Matrix_Changes());
status_text+=format;
break;
}
mytext->Reset();
mytext->Set_Location(Vector2(0.0,0.0));
mytext->Draw_Text(status_text,0xffff0000);
}
// ----------------------------------------------------------------------------
void Init_Assets()
{
TextureClass *tex=AssetManager->Get_Texture("PPVF0102.TGA");
REF_PTR_RELEASE(tex);
// Preload test assets. Note that not all of these will actually be used.
/* AssetManager->Load_3D_Assets("GreenSphere.w3d"); // Tests regular meshes
AssetManager->Load_3D_Assets("TexSphere.w3d"); // Tests texture mapping
AssetManager->Load_3D_Assets("TexScrlSphere.w3d"); // Tests Linear Offset mapper
AssetManager->Load_3D_Assets("SphereAnim.w3d"); // Tests hierarchical animation (if you install its anim)
AssetManager->Load_3D_Assets("SkinTest.w3d"); // Tests skinning and environment mapping
AssetManager->Load_3D_Assets("sorting_test.w3d"); // Tests skinning and environment mapping
AssetManager->Load_3D_Assets("boxtest.w3d"); // Tests BoxRenderObjClass (turn on the box display mask)
AssetManager->Load_3D_Assets("Test1.w3d"); // Test yellow particles
AssetManager->Load_3D_Assets("Test2.w3d"); // Tests alpha particles
AssetManager->Load_3D_Assets("MPassSphere.w3d"); // Tests more than 2 passes on a mesh
AssetManager->Load_3D_Assets("MPassTeapot.w3d"); // Tests more that 2 passes
AssetManager->Load_3D_Assets("DupSphere.w3d"); // Tests 3 passes which all share the same uv coords
AssetManager->Load_3D_Assets("vcolortest.w3d"); // Tests vertex color
AssetManager->Load_3D_Assets("valphatest.w3d"); // Tests vertex alpha
AssetManager->Load_3D_Assets("LightmapTest0.w3d"); // Tests pre-lighting, 3 solves: vertex, multi-pass, multi-stage
AssetManager->Load_3D_Assets("LightmapTest1.w3d"); // Tests pre-lighting with alternate solves! (not currently runtime switchable)
AssetManager->Load_3D_Assets("CubeSkin.w3d"); // Tests a simple skin, also can be used to test decals on skin meshes
AssetManager->Load_3D_Assets("ProjectorTest.w3d"); // This model contains a mesh and an animated "ProjectorBone" for testing texture projections
AssetManager->Load_3D_Assets("PolyRateTest.w3d"); // This model has lots of polys!
AssetManager->Load_3D_Assets("PPVF01A.w3d"); // Game asset
AssetManager->Load_3D_Assets("SPHERE_TEST.w3d"); // Tests multitexturing
AssetManager->Load_3D_Assets("SCREEN_ALIGN.w3d"); // Tests camera aligned meshes
AssetManager->Load_3D_Assets("halfsphere.w3d"); // Tests two-sided flag, camera aligned, and camera oriented meshes
AssetManager->Load_3D_Assets("tsi01a.w3d"); // Tests static sort level
AssetManager->Load_3D_Assets("tsi08a.w3d"); // Tests static sort level
*/
AssetManager->Load_3D_Assets("area1-LM.w3d");
/*
AssetManager->Load_3D_Assets("S_A_Human.W3D");
AssetManager->Load_3D_Assets("c_nod_rsold_L0.W3D");
AssetManager->Load_3D_Assets("h_a_a0a1.W3D");
*/
}
// ----------------------------------------------------------------------------
//
// Create a scene for 2D-display, such as text and rectangles.
//
// ----------------------------------------------------------------------------
void Init_2D_Scene()
{
// Create a scene for the 2D stuff -----------------------------------------
my_2d_scene=NEW_REF(SimpleSceneClass,());
my_2d_scene->Set_Ambient_Light(Vector3(1,1,1));
// Create fonts to be used for text rendering ------------------------------
my_font_a = AssetManager->Get_Font3DInstance("font12x16.tga");
my_font_b = AssetManager->Get_Font3DInstance("fontnew4.tga");
mytext=new Render2DTextClass(my_font_b);
mytext->Set_Coordinate_Range( Render2DClass::Get_Screen_Resolution() );
// Scene needs camera to be rendered with ----------------------------------
my_2d_camera = NEW_REF(CameraClass,());
#ifdef DRAWBITMAP
my_2d_camera->Set_Position(Vector3(0,0,1));
my_2d_camera->Set_Clip_Planes(0.995,2);
#else
my_2d_camera->Set_Position(Vector3(0,0,320));
my_2d_camera->Set_Clip_Planes(300,1000);
#endif
Vector2 min = Vector2(-1, -0.75f);
Vector2 max = Vector2(+1, +0.75f);
my_2d_camera->Set_View_Plane(min, max);
}
void Init_3D_Scene()
{
WW3D::Enable_Sorting(false);
WW3D::Set_NPatches_Level(1);
// build scene
my_scene=NEW_REF(SkeletonSceneClass,());
my_scene->Set_Ambient_Light(Vector3(0.5f,0.5f,0.5f));
// set up a light
my_lights[0]=my_lights[1]=my_lights[2]=NULL;
my_lights[0]=NEW_REF(LightClass,(LightClass::DIRECTIONAL));
my_lights[0]->Set_Ambient(Vector3(0.1f,0.1f,0.1f));
my_lights[0]->Set_Diffuse(Vector3(1.0f,1.0f,1.0f));
my_lights[0]->Set_Spot_Direction(Vector3(0,1,0));
my_scene->Add_Render_Object(my_lights[0]);
// Scene needs camera to be rendered with ----------------------------------
my_camera=NEW_REF(CameraClass,());
Matrix3D camtransform(1);
camtransform.Look_At(CAMERA_POSITION,CAMERA_TARGET,0);
my_camera->Set_Transform(camtransform);
my_object = AssetManager->Create_Render_Obj(OBJECT_NAME);
if (ANIM_NAME != NULL) {
my_anim = AssetManager->Get_HAnim(ANIM_NAME);
}
if (my_object != NULL) {
my_object->Set_Position(OBJECT_POSITION);
#if 0
Enable_Alternate_Materials(my_object,true);
#endif
// Decal System
#if 0
Matrix3D decal_tm;
decal_tm.Look_At(Vector3(30,5,10),Vector3(0,0,10),DEG_TO_RADF(65.5f));
Create_Decal(my_object,decal_tm,13.7f,"decal.tga");
#endif
// PredictiveLODOptimizerClass::Add_Object(my_object);
my_object->Set_Position(Vector3(0,0,0));
if (my_anim != NULL) {
my_object->Set_Animation(my_anim,0,RenderObjClass::ANIM_MODE_LOOP);
}
my_scene->Add_Render_Object(my_object);
if (my_object->Class_ID()==RenderObjClass::CLASSID_PARTICLEEMITTER) {
((ParticleEmitterClass*) my_object)->Start();
}
}
// 3D line object ----------------------------------------------------------
#if 0
Line3DClass *line = NULL;
line = NEW_REF(Line3DClass,(Vector3(0,0,0),Vector3(100,100,0), 10,1,1,1,1));
my_scene->Add_Render_Object(line);
REF_PTR_RELEASE(line); // Obejct can be freed after adding scene so that it gets killed when scene dies
#endif
// Create texture projector material pass ----------------------------------
#if 0
my_texture_projector = Create_Texture_Projector();
my_scene->Set_Material_Pass(my_texture_projector->Peek_Material_Pass());
// REF_PTR_RELEASE(my_texture_projector);
#endif
// Create material pass ----------------------------------------------------
#if 0
my_material_pass = Create_Material_Pass();
my_scene->Set_Material_Pass(my_material_pass);
REF_PTR_RELEASE(my_material_pass);
#endif
}
Reference in a new issue View git blame Copy permalink