mirror of
https://github.com/dpethes/rerogue.git
synced 2025-06-07 18:58:32 +02:00
612 lines
18 KiB
ObjectPascal
612 lines
18 KiB
ObjectPascal
(*
|
|
Copyright (c) 2017 David Pethes
|
|
|
|
This file is part of RS model viewer.
|
|
|
|
RS model viewer 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.
|
|
|
|
RS model viewer 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 RS model viewer. If not, see <http://www.gnu.org/licenses/>.
|
|
*)
|
|
program model_viewer;
|
|
|
|
uses
|
|
sysutils, classes, math, strutils, gvector,
|
|
gl, glu, glext, sdl2, fpimgui, fpimgui_impl_sdlgl2,
|
|
rs_dat, hob_mesh,
|
|
png_writer, dc2core;
|
|
|
|
const
|
|
SCR_W_INIT = 1280;
|
|
SCR_H_INIT = 720;
|
|
RotationAngleIncrement = 1;
|
|
ZoomIncrement = 0.3;
|
|
MouseZoomDistanceMultiply = 0.15;
|
|
PitchIncrement = 0.5;
|
|
MouseTranslateMultiply = 0.025;
|
|
|
|
type
|
|
TFileListItem = record
|
|
name: string;
|
|
node_hob: PRsDatFileNode;
|
|
node_hmt: PRsDatFileNode;
|
|
end;
|
|
TFileList = specialize TVector<TFileListItem>;
|
|
|
|
var
|
|
g_window: PSDL_Window;
|
|
g_ogl_context: TSDL_GLContext;
|
|
|
|
g_rs_files: TRsDatFileNodeList;
|
|
g_filelist: TFileList;
|
|
g_selected_file_idx: integer;
|
|
g_model: TModel;
|
|
g_model_loading_failed: Boolean;
|
|
|
|
view: record
|
|
rotation_angle: single;
|
|
distance: single;
|
|
pitch: single;
|
|
x, y: single;
|
|
autorotate: boolean;
|
|
render: TRenderOpts;
|
|
mesh: TMeshOpts;
|
|
end;
|
|
|
|
key_pressed: record
|
|
wireframe: boolean;
|
|
vcolors: boolean;
|
|
points: boolean;
|
|
textures: boolean;
|
|
fullscreen: boolean;
|
|
autorotate: boolean;
|
|
fg: boolean;
|
|
end;
|
|
|
|
mouse: record
|
|
drag: boolean;
|
|
translate: boolean;
|
|
last_x, last_y: integer;
|
|
resume_autorotate_on_release: boolean;
|
|
end;
|
|
|
|
procedure AppError(s: string);
|
|
begin
|
|
writeln(stderr, s);
|
|
halt;
|
|
end;
|
|
|
|
|
|
// initial parameters
|
|
procedure InitGL;
|
|
var
|
|
ogl_info: string;
|
|
begin
|
|
ogl_info := format('vendor: %s renderer: %s', [glGetString(GL_VENDOR), glGetString(GL_RENDERER)]);
|
|
writeln(ogl_info);
|
|
ogl_info := 'version: ' + glGetString(GL_VERSION);
|
|
writeln(ogl_info);
|
|
|
|
//glShadeModel( GL_SMOOTH ); // Enable smooth shading
|
|
glClearColor( 0.0, 0.0, 0.0, 0.0 );
|
|
glClearDepth( 1.0 ); // Depth buffer setup
|
|
glEnable( GL_DEPTH_TEST ); // Enables Depth Testing
|
|
glDepthFunc( GL_LEQUAL ); // The Type Of Depth Test To Do
|
|
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ); // Really Nice Perspective Calculations
|
|
|
|
//glEnable( GL_CULL_FACE ); //backface culling
|
|
//glCullFace( GL_BACK );
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
end;
|
|
|
|
|
|
// function to reset our viewport after a window resize
|
|
procedure SetGLWindowSize( width, height : integer );
|
|
begin
|
|
if ( height = 0 ) then
|
|
height := 1; // Protect against a divide by zero
|
|
|
|
glViewport( 0, 0, width, height ); // Setup our viewport.
|
|
glMatrixMode( GL_PROJECTION ); // change to the projection matrix and set our viewing volume.
|
|
glLoadIdentity;
|
|
gluPerspective(45.0, width / height, 0.1, 100.0); // Set our perspective
|
|
// glOrtho( 0, width, height, 0, - 1, 1);
|
|
glMatrixMode( GL_MODELVIEW ); // Make sure we're changing the model view and not the projection
|
|
glLoadIdentity; // Reset The View
|
|
end;
|
|
|
|
|
|
// The main drawing function.
|
|
procedure DrawModel;
|
|
begin
|
|
glLoadIdentity;
|
|
|
|
if view.distance < ZoomIncrement then
|
|
view.distance := ZoomIncrement;
|
|
|
|
glTranslatef(view.x, view.y, -view.distance);
|
|
glRotatef(view.rotation_angle, 0.0, 1.0, 0.0);
|
|
glRotatef(view.pitch, 1, 0, 0);
|
|
|
|
if view.autorotate then
|
|
view.rotation_angle += RotationAngleIncrement;
|
|
if view.rotation_angle > 360 then
|
|
view.rotation_angle -= 360;
|
|
|
|
if g_model <> nil then begin
|
|
g_model.DrawGL(view.render);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure WindowInit(w_width, w_height: integer);
|
|
var
|
|
ver: TSDL_Version;
|
|
x, y: integer;
|
|
flags: longword;
|
|
io: PImGuiIO;
|
|
begin
|
|
SDL_GetVersion(@ver);
|
|
writeln(format('SDL %d.%d.%d', [ver.major, ver.minor, ver.patch]));
|
|
//WriteVideoInfo;
|
|
|
|
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
|
|
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
|
|
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
|
|
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
|
|
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
|
|
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
|
|
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
|
|
|
|
WriteLn('init window: ', w_width, 'x', w_height);
|
|
x := SDL_WINDOWPOS_CENTERED;
|
|
y := SDL_WINDOWPOS_CENTERED;
|
|
flags := SDL_WINDOW_SHOWN or SDL_WINDOW_OPENGL or SDL_WINDOW_RESIZABLE;
|
|
g_window := SDL_CreateWindow('RS model viewer', x, y, w_width, w_height, flags);
|
|
if g_window = nil then
|
|
AppError ('SDL_CreateWindow failed. Reason: ' + SDL_GetError());
|
|
|
|
g_ogl_context := SDL_GL_CreateContext(g_window);
|
|
if g_ogl_context = nil then begin
|
|
writeln ('SDL_GL_CreateContext failed. Reason: ' + SDL_GetError());
|
|
halt;
|
|
end;
|
|
SDL_GL_SetSwapInterval(1); //enable VSync
|
|
|
|
//setup imgui
|
|
io := igGetIO();
|
|
io^.DisplaySize.x := w_width;
|
|
io^.DisplaySize.y := w_height;
|
|
ImGui_ImplSdlGL2_Init();
|
|
end;
|
|
|
|
|
|
procedure WindowFree;
|
|
begin
|
|
ImGui_ImplSdlGL2_Shutdown();
|
|
SDL_GL_DeleteContext(g_ogl_context);
|
|
SDL_DestroyWindow(g_window);
|
|
end;
|
|
|
|
|
|
procedure WindowScreenshot(const width, height : integer);
|
|
const
|
|
head: array[0..8] of word = (0, 2, 0, 0, 0, 0, 0, 0, 24);
|
|
counter: integer = 0;
|
|
var
|
|
buf: pbyte;
|
|
f: file;
|
|
fname: string;
|
|
begin
|
|
buf := getmem(width * height * 4);
|
|
glReadBuffer(GL_FRONT);
|
|
glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, buf);
|
|
|
|
fname := format('screenshot_%.4d.tga', [counter]);
|
|
AssignFile(f, fname);
|
|
Rewrite(f, 1);
|
|
head[6] := width;
|
|
head[7] := height;
|
|
BlockWrite(f, head, sizeof(head));
|
|
BlockWrite(f, buf^, width * height * 3);
|
|
CloseFile(f);
|
|
counter += 1;
|
|
|
|
Freemem(buf);
|
|
end;
|
|
|
|
|
|
procedure InitView;
|
|
begin
|
|
view.rotation_angle := 0;
|
|
view.distance := 3;
|
|
view.pitch := 0;
|
|
view.x := 0;
|
|
view.y := 0;
|
|
view.autorotate := true;
|
|
|
|
view.render.show_all_parts := true;
|
|
view.render.part_to_draw := 0;
|
|
view.render.obj_to_draw := 0;
|
|
view.render.wireframe := false;
|
|
view.render.points := false;
|
|
view.render.vcolors := true;
|
|
view.render.textures := true;
|
|
end;
|
|
|
|
|
|
//Beware, not all models can be parsed correctly yet. This will leak then, but we don't care much.
|
|
procedure LoadMesh(item: TFileListItem);
|
|
var
|
|
hob, hmt: TMemoryStream;
|
|
begin
|
|
try
|
|
if g_model <> nil then
|
|
g_model.Free;
|
|
hob := TMemoryStream.Create;
|
|
hob.WriteBuffer(item.node_hob^.Data^, item.node_hob^.size);
|
|
hob.Seek(0, soBeginning);
|
|
|
|
hmt := TMemoryStream.Create;
|
|
hmt.WriteBuffer(item.node_hmt^.Data^, item.node_hmt^.size);
|
|
hmt.Seek(0, soBeginning);
|
|
|
|
g_model := TModel.Create;
|
|
g_model.Load(hob, hmt);
|
|
|
|
hob.Free;
|
|
hmt.Free;
|
|
g_model_loading_failed := false;
|
|
except
|
|
g_model_loading_failed := true;
|
|
end;
|
|
view.render.part_to_draw := 0;
|
|
end;
|
|
|
|
|
|
procedure HandleEvent(const ev: TSDL_Event; var done: boolean);
|
|
var
|
|
io: PImGuiIO;
|
|
begin
|
|
ImGui_ImplSdlGL2_ProcessEvent(@ev);
|
|
io := igGetIO();
|
|
if ((ev.type_ = SDL_MOUSEBUTTONDOWN) or
|
|
(ev.type_ = SDL_MOUSEBUTTONUP) or
|
|
(ev.type_ = SDL_MOUSEWHEEL) or
|
|
(ev.type_ = SDL_MOUSEMOTION)) and io^.WantCaptureMouse then
|
|
exit;
|
|
if ((ev.type_ = SDL_KEYDOWN) or (ev.type_ = SDL_KEYUP)) and io^.WantCaptureKeyboard then
|
|
exit;
|
|
|
|
case ev.type_ of
|
|
SDL_QUITEV:
|
|
Done := true;
|
|
SDL_WINDOWEVENT: begin
|
|
if ev.window.event = SDL_WINDOWEVENT_RESIZED then
|
|
SetGLWindowSize(ev.window.data1, ev.window.data2);
|
|
end;
|
|
|
|
SDL_KEYDOWN: begin
|
|
case ev.key.keysym.sym of
|
|
SDLK_ESCAPE:
|
|
Done := true;
|
|
SDLK_s:
|
|
WindowScreenshot(g_window^.w, g_window^.h);
|
|
SDLK_PAGEUP:
|
|
view.distance += ZoomIncrement;
|
|
SDLK_PAGEDOWN:
|
|
view.distance -= ZoomIncrement;
|
|
SDLK_r:
|
|
if not key_pressed.autorotate then begin
|
|
view.autorotate := not view.autorotate;
|
|
key_pressed.autorotate := true;
|
|
if not view.autorotate then
|
|
view.rotation_angle := 0;
|
|
end;
|
|
|
|
//model rendering options
|
|
SDLK_w:
|
|
if not key_pressed.wireframe then begin
|
|
view.render.wireframe := not view.render.wireframe;
|
|
key_pressed.wireframe := true;
|
|
end;
|
|
SDLK_v:
|
|
if not key_pressed.vcolors then begin
|
|
view.render.vcolors := not view.render.vcolors;
|
|
key_pressed.vcolors := true;
|
|
end;
|
|
SDLK_p:
|
|
if not key_pressed.points then begin
|
|
view.render.points := not view.render.points;
|
|
key_pressed.points := true;
|
|
end;
|
|
SDLK_t:
|
|
if not key_pressed.textures then begin
|
|
view.render.textures := not view.render.textures;
|
|
key_pressed.textures := true;
|
|
end;
|
|
|
|
//model selection
|
|
SDLK_f:
|
|
view.render.show_all_parts := not view.render.show_all_parts;
|
|
SDLK_LEFT: begin
|
|
view.render.show_all_parts := false;
|
|
view.render.part_to_draw := max(0, view.render.part_to_draw - 1);
|
|
end;
|
|
SDLK_RIGHT: begin
|
|
view.render.show_all_parts := false;
|
|
view.render.part_to_draw += 1;
|
|
end;
|
|
SDLK_END:
|
|
view.render.obj_to_draw += 1;
|
|
SDLK_HOME:
|
|
view.render.obj_to_draw := max(0, view.render.obj_to_draw - 1);
|
|
|
|
SDLK_UP:
|
|
if (g_selected_file_idx > 0) then begin
|
|
g_selected_file_idx -= 1;
|
|
view.render.part_to_draw := 0;
|
|
view.render.obj_to_draw := 0;
|
|
LoadMesh(g_filelist[g_selected_file_idx]);
|
|
end;
|
|
SDLK_DOWN:
|
|
if (g_selected_file_idx < g_filelist.Size - 1) then begin
|
|
g_selected_file_idx += 1;
|
|
view.render.part_to_draw := 0;
|
|
view.render.obj_to_draw := 0;
|
|
LoadMesh(g_filelist[g_selected_file_idx]);
|
|
end;
|
|
end;
|
|
end;
|
|
SDL_KEYUP: begin
|
|
case ev.key.keysym.sym of
|
|
SDLK_F1:
|
|
key_pressed.fullscreen := false;
|
|
SDLK_w:
|
|
key_pressed.wireframe := false;
|
|
SDLK_v:
|
|
key_pressed.vcolors := false;
|
|
SDLK_p:
|
|
key_pressed.points := false;
|
|
SDLK_t:
|
|
key_pressed.textures := false;
|
|
SDLK_r:
|
|
key_pressed.autorotate := false;
|
|
end;
|
|
end;
|
|
|
|
SDL_MOUSEBUTTONDOWN: begin
|
|
mouse.resume_autorotate_on_release := view.autorotate;
|
|
if ev.button.button in [1..3] then begin
|
|
mouse.drag := true;
|
|
mouse.translate := ev.button.button = 2;
|
|
mouse.last_x := ev.button.x;
|
|
mouse.last_y := ev.button.y;
|
|
view.autorotate := false;
|
|
end;
|
|
end;
|
|
SDL_MOUSEBUTTONUP: begin
|
|
mouse.drag := false;
|
|
view.autorotate := mouse.resume_autorotate_on_release;
|
|
end;
|
|
SDL_MOUSEWHEEL: begin
|
|
if ev.wheel.y < 0 then
|
|
view.distance += view.distance * MouseZoomDistanceMultiply;
|
|
if ev.wheel.y > 0 then
|
|
view.distance -= view.distance * MouseZoomDistanceMultiply;
|
|
end;
|
|
SDL_MOUSEMOTION: begin
|
|
if mouse.drag then begin
|
|
if not mouse.translate then begin
|
|
if ev.motion.y <> mouse.last_y then begin
|
|
view.pitch += PitchIncrement * ev.motion.yrel;
|
|
mouse.last_y := ev.motion.y;
|
|
end;
|
|
if ev.motion.x <> mouse.last_x then begin
|
|
view.rotation_angle += RotationAngleIncrement * ev.motion.xrel;
|
|
mouse.last_x := ev.motion.x;
|
|
end;
|
|
end else begin
|
|
if ev.motion.y <> mouse.last_y then begin
|
|
view.y -= MouseTranslateMultiply * ev.motion.yrel;
|
|
mouse.last_y := ev.motion.y;
|
|
end;
|
|
if ev.motion.x <> mouse.last_x then begin
|
|
view.x += MouseTranslateMultiply * ev.motion.xrel;
|
|
mouse.last_x := ev.motion.x;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
end; {case}
|
|
end;
|
|
|
|
|
|
procedure DrawGui;
|
|
var
|
|
file_item: TFileListItem;
|
|
selected_item_idx: integer;
|
|
selected_item: TFileListItem;
|
|
i: Integer;
|
|
do_export: boolean;
|
|
begin
|
|
if g_selected_file_idx >= 0 then begin
|
|
Imgui.Begin_('Mesh'); //window used in hob_mesh as well
|
|
if not g_model_loading_failed then begin
|
|
Imgui.Text(g_filelist[g_selected_file_idx].name);
|
|
end else
|
|
Imgui.Text('mesh loading failed :(');
|
|
if g_model <> nil then begin
|
|
do_export := Imgui.Button('Export to obj');
|
|
Imgui.SameLine(0, 15);
|
|
Imgui.Checkbox('with png textures', @view.mesh.export_png_textures);
|
|
if do_export then
|
|
g_model.ExportObj('rs_exported.obj', view.mesh.export_png_textures);
|
|
end;
|
|
Imgui.End_;
|
|
end;
|
|
|
|
Imgui.Begin_('Rendering options');
|
|
Imgui.Checkbox('points', @view.render.points);
|
|
Imgui.Checkbox('wireframe', @view.render.wireframe);
|
|
Imgui.Checkbox('textures', @view.render.textures);
|
|
Imgui.Checkbox('vertex colors', @view.render.vcolors);
|
|
Imgui.End_;
|
|
|
|
Imgui.Begin_('Help');
|
|
Imgui.Text('Keys:');
|
|
Imgui.Text('S - take screenshot');
|
|
Imgui.Text('R - autorotate on/off');
|
|
Imgui.Text('F - show all object parts on/off');
|
|
Imgui.Text('left/right arrow - show previous/next object part');
|
|
Imgui.Text('Home/End - show previous/next object');
|
|
Imgui.Text('top/down arrow - go to previous/next file');
|
|
Imgui.End_;
|
|
|
|
if g_filelist.Size = 0 then
|
|
exit;
|
|
|
|
selected_item_idx := -1;
|
|
//todo scrolling, filter?
|
|
Imgui.Begin_('File list');
|
|
for i := 0 to g_filelist.Size - 1 do begin
|
|
file_item := g_filelist[i];
|
|
if Imgui.Selectable(file_item.name, g_selected_file_idx = i) then begin
|
|
selected_item_idx := i;
|
|
selected_item := file_item;
|
|
end;
|
|
end;
|
|
Imgui.End_;
|
|
|
|
if (selected_item_idx >= 0) and (selected_item_idx <> g_selected_file_idx) then begin
|
|
g_selected_file_idx := selected_item_idx;
|
|
LoadMesh(selected_item);
|
|
end;
|
|
end;
|
|
|
|
//we only care about HOB and HMT files
|
|
procedure LoadMeshFilelist;
|
|
procedure AddFile(const path: string; const fnode, fnode_next: PRsDatFileNode);
|
|
var
|
|
item: TFileListItem;
|
|
name: String;
|
|
i: integer;
|
|
begin
|
|
if fnode^.is_directory then begin
|
|
for i := 0 to Length(fnode^.nodes)-2 do //hob/hmt always go in pairs
|
|
AddFile(path + fnode^.Name + '/', fnode^.nodes[i], fnode^.nodes[i+1]);
|
|
AddFile(path + fnode^.Name + '/', fnode^.nodes[Length(fnode^.nodes)-1], nil); // in case last is a directory (e.g. dbg)
|
|
end
|
|
else begin
|
|
name := fnode^.name;
|
|
if AnsiEndsText('hob', name) then begin
|
|
Assert(AnsiEndsText('hmt', fnode_next^.name), 'no HMT file!');
|
|
item.name := path + name;
|
|
item.node_hob := fnode;
|
|
item.node_hmt := fnode_next;
|
|
g_filelist.PushBack(item);
|
|
end;
|
|
end;
|
|
end;
|
|
var
|
|
file_: TRsDatFileNode;
|
|
begin
|
|
for file_ in g_rs_files do begin
|
|
AddFile('', @file_, nil);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure BeginScene;
|
|
var
|
|
style: PImGuiStyle;
|
|
begin
|
|
ImGui_ImplSdlGL2_NewFrame(g_window);
|
|
style := Imgui.GetStyle();
|
|
style^.WindowRounding := 0;
|
|
glClear( GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT );
|
|
end;
|
|
|
|
procedure EndScene;
|
|
begin
|
|
igRender;
|
|
SDL_GL_SwapWindow(g_window);
|
|
end;
|
|
|
|
//******************************************************************************
|
|
var
|
|
rsdata: TRSDatFile;
|
|
sec, frames: integer;
|
|
event: TSDL_Event;
|
|
done: boolean;
|
|
|
|
begin
|
|
if not (FileExists(RS_DATA_HDR) and FileExists(RS_DATA_DAT)) then begin
|
|
writeln('RS data files not found!');
|
|
exit;
|
|
end;
|
|
|
|
writeln('loading data');
|
|
rsdata := TRSDatFile.Create(RS_DATA_HDR, RS_DATA_DAT);
|
|
rsdata.Parse();
|
|
g_rs_files := rsdata.GetStructure();
|
|
g_filelist := TFileList.Create;
|
|
LoadMeshFilelist();
|
|
|
|
writeln('Init SDL...');
|
|
SDL_Init(SDL_INIT_VIDEO or SDL_INIT_TIMER);
|
|
WindowInit(SCR_W_INIT, SCR_H_INIT);
|
|
writeln('Init OpenGL...');
|
|
InitGL;
|
|
SetGLWindowSize(g_window^.w, g_window^.h);
|
|
|
|
InitView;
|
|
g_model := nil;
|
|
g_selected_file_idx := 0;
|
|
LoadMesh(g_filelist[0]);
|
|
|
|
sec := SDL_GetTicks;
|
|
frames := 0;
|
|
Done := False;
|
|
key_pressed.wireframe := false;
|
|
key_pressed.fullscreen := false;
|
|
while not Done do begin
|
|
BeginScene;
|
|
DrawModel;
|
|
DrawGui;
|
|
EndScene;
|
|
|
|
while SDL_PollEvent(@event) > 0 do
|
|
HandleEvent(event, done);
|
|
|
|
frames += 1;
|
|
if (SDL_GetTicks - sec) >= 1000 then begin
|
|
write(frames:3, ' dist: ', view.distance:5:1, ' rot: ', view.rotation_angle:5:1, #13);
|
|
frames := 0;
|
|
sec := SDL_GetTicks;
|
|
end;
|
|
SDL_Delay(5);
|
|
//WindowScreenshot( surface^.w, surface^.h );
|
|
end;
|
|
|
|
{$ifdef DEBUG}
|
|
if g_model <> nil then
|
|
g_model.Free;
|
|
WindowFree;
|
|
SDL_Quit;
|
|
g_filelist.Free;
|
|
g_rs_files.Free;
|
|
rsdata.Free;
|
|
{$endif}
|
|
end.
|
|
|