Descent3/editor/WaterProceduralDialog.cpp

/*
 * Descent 3
 * Copyright (C) 2024 Parallax Software
 *
 * 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/>.
 */

// WaterProceduralDialog.cpp : implementation file
//

#include "mfc_compatibility.h"
#include "editor.h"
#include "game.h"
#include "manage.h"
#include "texpage.h"

#include "WaterProceduralDialog.h"
// #include "procedurals.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CWaterProceduralDialog dialog

#define MAX_SLIDER_RANGE 255

CWaterProceduralDialog::CWaterProceduralDialog(CWnd *pParent /*=NULL*/)
    : CDialog(CWaterProceduralDialog::IDD, pParent) {
  //{{AFX_DATA_INIT(CWaterProceduralDialog)
  // NOTE: the ClassWizard will add member initialization here
  //}}AFX_DATA_INIT
}

void CWaterProceduralDialog::DoDataExchange(CDataExchange *pDX) {
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CWaterProceduralDialog)
  DDX_Control(pDX, IDC_WP_LIGHT_SLIDER, m_light_slider);
  DDX_Control(pDX, IDC_WP_THICKNESS_SLIDER, m_thickness_slider);
  DDX_Control(pDX, IDC_WP_SIZE_SLIDER, m_size_slider);
  DDX_Control(pDX, IDC_WP_HEIGHT_SLIDER, m_height_slider);
  DDX_Control(pDX, IDC_WP_FREQUENCY_SLIDER, m_frequency_slider);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CWaterProceduralDialog, CDialog)
//{{AFX_MSG_MAP(CWaterProceduralDialog)
ON_CBN_SELENDOK(IDC_PROCEDURAL_PULLDOWN, OnSelendokProceduralPulldown)
ON_WM_TIMER()
ON_BN_CLICKED(IDC_CLEAR_PROCEDURALS, OnClearProcedurals)
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
ON_EN_KILLFOCUS(IDC_PROC_EVAL_TIME_EDIT, OnKillfocusProcEvalTimeEdit)
ON_EN_KILLFOCUS(IDC_PROC_OSC_TIME_EDIT, OnKillfocusProcOscTimeEdit)
ON_EN_KILLFOCUS(IDC_PROC_OSC_VALUE_EDIT, OnKillfocusProcOscValueEdit)
ON_BN_CLICKED(IDC_COPY_PROCEDURAL, OnCopyProcedural)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWaterProceduralDialog message handlers

void CWaterProceduralDialog::OnSelendokProceduralPulldown() {
  int cur = SendDlgItemMessage(IDC_PROCEDURAL_PULLDOWN, CB_GETCURSEL, 0, 0);
  m_proc_type = cur;
  UpdateDialog();
}

static static_proc_element save_elements[8000];
BOOL CWaterProceduralDialog::DestroyWindow() {
  // TODO: Add your specialized code here and/or call the base class
  CWnd::KillTimer(1);

  int n = D3EditState.texdlg_texture;

  int save_num = 0;

  // Restore our static proc elements
  save_num = GameTextures[n].procedural->num_static_elements;

  if (save_num > 0)
    memcpy(save_elements, GameTextures[n].procedural->static_proc_elements, save_num * sizeof(static_proc_element));

  FreeStaticProceduralsForTexture(n);
  Sleep(2000);

  if (save_num > 0) {
    AllocateStaticProceduralsForTexture(n, save_num);
    memcpy(GameTextures[n].procedural->static_proc_elements, save_elements, save_num * sizeof(static_proc_element));
    GameTextures[n].procedural->num_static_elements = save_num;
  } else {
    GameTextures[n].flags &= ~(TF_PROCEDURAL | TF_WATER_PROCEDURAL);
  }

  bm_FreeBitmap(m_window_bitmap);
  m_TextureSurf.free();

  return CDialog::DestroyWindow();
}

void CWaterProceduralDialog::PrintValue(int whichbox, uint8_t val) {
  CEdit *ebox;
  char str[255];

  ebox = (CEdit *)GetDlgItem(whichbox);
  sprintf(str, "%d", val);
  ebox->SetWindowText(str);
}

void CWaterProceduralDialog::UpdateDialog() {
  int n = D3EditState.texdlg_texture;

  CEdit *ebox;
  char str[255];
  ebox = (CEdit *)GetDlgItem(IDC_PROC_EVAL_TIME_EDIT);
  sprintf(str, "%f", GameTextures[n].procedural->evaluation_time);
  ebox->SetWindowText(str);

  ebox = (CEdit *)GetDlgItem(IDC_PROC_OSC_TIME_EDIT);
  sprintf(str, "%f", GameTextures[n].procedural->osc_time);
  ebox->SetWindowText(str);

  ebox = (CEdit *)GetDlgItem(IDC_PROC_OSC_VALUE_EDIT);
  sprintf(str, "%d", GameTextures[n].procedural->osc_value);
  ebox->SetWindowText(str);

  // Update procedural box
  SendDlgItemMessage(IDC_PROCEDURAL_PULLDOWN, CB_RESETCONTENT, 0, 0);
  for (int i = 0; stricmp("End", WaterProcNames[i]) != 0; i++) {
    SendDlgItemMessage(IDC_PROCEDURAL_PULLDOWN, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)WaterProcNames[i]);
  }
  SendDlgItemMessage(IDC_PROCEDURAL_PULLDOWN, CB_SELECTSTRING, 0, (LPARAM)(LPCTSTR)WaterProcNames[m_proc_type]);

  // fill in the combo box for copy procedural data
  CComboBox *combo;
  combo = (CComboBox *)GetDlgItem(IDC_PROC_COPY_LIST);
  combo->ResetContent();
  for (i = 0; i < MAX_TEXTURES; i++) {
    if (!GameTextures[i].used)
      continue;
    if (i == D3EditState.texdlg_texture)
      continue;
    if (!(GameTextures[i].flags & TF_PROCEDURAL))
      continue;
    if (!(GameTextures[i].flags & TF_WATER_PROCEDURAL))
      continue;
    combo->AddString(GameTextures[i].name);
  }
  combo->SetCurSel(0);
}

void CWaterProceduralDialog::UpdateProcView() {
  int n = D3EditState.texdlg_texture;

  FrameCount++;

  CWnd *texwnd;
  RECT rect;

  texwnd = GetDlgItem(IDC_WATER_PROCEDURAL_VIEW);
  texwnd->GetWindowRect(&rect);
  ScreenToClient(&rect);

  int w = rect.right - rect.left;
  int h = rect.bottom - rect.top;

  Desktop_surf->attach_to_window((unsigned)m_hWnd);

  int bm_handle = GetTextureBitmap(n, 0, 1);

  if (GameBitmaps[bm_handle].flags & BF_MIPMAPPED)
    GameBitmaps[m_window_bitmap].flags |= BF_MIPMAPPED;

  bm_ScaleBitmapToBitmap(m_window_bitmap, bm_handle);

  m_TextureSurf.load(m_window_bitmap);

  int x = rect.left + ((rect.right - rect.left) / 2) - m_TextureSurf.width() / 2;
  int y = rect.top + ((rect.bottom - rect.top) / 2) - m_TextureSurf.height() / 2;

  Desktop_surf->blt(x, y, &m_TextureSurf);

  // Do slider values
  m_frequency = 255 - m_frequency_slider.GetPos();
  m_height = m_height_slider.GetPos();
  m_size = m_size_slider.GetPos();

  GameTextures[n].procedural->light = m_light_slider.GetPos();
  GameTextures[n].procedural->thickness = m_thickness_slider.GetPos();

  PrintValue(IDC_SIZE_TEXT, m_size);
  PrintValue(IDC_HEIGHT_TEXT, m_height);
  PrintValue(IDC_FREQ_TEXT, 255 - m_frequency);
  PrintValue(IDC_LIGHT_TEXT, GameTextures[n].procedural->light);
  PrintValue(IDC_THICKNESS_TEXT, GameTextures[n].procedural->thickness);
}

void CWaterProceduralDialog::OnTimer(UINT nIDEvent) {
  // TODO: Add your message handler code here and/or call default
  UpdateProcView();

  CDialog::OnTimer(nIDEvent);
}

BOOL CWaterProceduralDialog::OnInitDialog() {
  CDialog::OnInitDialog();

  CWnd::SetTimer(1, 33, NULL); // 30 frames per second

  int save_num = 0;
  int n = D3EditState.texdlg_texture;

  // Make a temp buffer for our static elements
  if (GameTextures[n].procedural->num_static_elements > 0) {
    save_num = GameTextures[n].procedural->num_static_elements;
    memcpy(save_elements, GameTextures[n].procedural->static_proc_elements, save_num * sizeof(static_proc_element));
  }

  FreeStaticProceduralsForTexture(n);
  Sleep(2000);
  AllocateStaticProceduralsForTexture(n, 8000);

  memcpy(GameTextures[n].procedural->static_proc_elements, save_elements, save_num * sizeof(static_proc_element));
  GameTextures[n].procedural->num_static_elements = save_num;

  m_button_down = 0;
  m_proc_type = 0;
  m_size = 1;
  m_height = 1;
  m_frequency = 0;

  // Alloc bitmap
  CWnd *texwnd;
  RECT rect;

  texwnd = GetDlgItem(IDC_WATER_PROCEDURAL_VIEW);
  texwnd->GetWindowRect(&rect);
  ScreenToClient(&rect);

  int w = rect.right - rect.left;
  int h = rect.bottom - rect.top;

  m_window_bitmap = bm_AllocBitmap(w, h, ((w * h) / 3) * 2);
  ASSERT(m_window_bitmap >= 0);
  m_TextureSurf.create(bm_w(m_window_bitmap, 0), bm_h(m_window_bitmap, 0), bm_bpp(m_window_bitmap));

  m_frequency_slider.SetRange(0, MAX_SLIDER_RANGE);
  m_frequency_slider.SetPos(255 - m_frequency);

  m_height_slider.SetRange(1, MAX_SLIDER_RANGE);
  m_height_slider.SetPos(m_height);

  m_size_slider.SetRange(1, MAX_SLIDER_RANGE);
  m_size_slider.SetPos(m_size);

  m_light_slider.SetRange(0, 12);
  m_light_slider.SetPos(GameTextures[n].procedural->light);

  m_thickness_slider.SetRange(0, 12);
  m_thickness_slider.SetPos(GameTextures[n].procedural->thickness);

  UpdateDialog();

  // TODO: Add extra initialization here

  return TRUE; // return TRUE unless you set the focus to a control
               // EXCEPTION: OCX Property Pages should return FALSE
}

void CWaterProceduralDialog::OnClearProcedurals() { ClearAllProceduralsFromTexture(D3EditState.texdlg_texture); }

void CWaterProceduralDialog::HarvestValue(int whichbox, uint8_t *val) {
  CEdit *ebox;
  char name[20];
  int num = 0;

  ebox = (CEdit *)GetDlgItem(whichbox);
  ebox->GetWindowText(name, 20);

  num = atoi(name);
  if (num < 0)
    num = 0;
  if (num > 255)
    num = 255;

  *val = num;

  UpdateDialog();
}

void CWaterProceduralDialog::OnLButtonDown(UINT nFlags, CPoint point) {
  CPoint tpoint = point;
  CWnd *texwnd;
  RECT rect;
  int n = D3EditState.texdlg_texture;

  texwnd = GetDlgItem(IDC_WATER_PROCEDURAL_VIEW);
  texwnd->GetWindowRect(&rect);

  int w = rect.right - rect.left;
  int h = rect.bottom - rect.top;

  MapWindowPoints(texwnd, &tpoint, 1);

  if (tpoint.x < 0)
    return;
  if (tpoint.y < 0)
    return;

  if (tpoint.x >= w)
    return;
  if (tpoint.y >= h)
    return;

  int bm_handle = GameTextures[n].procedural->procedural_bitmap;
  int bw = bm_w(bm_handle, 0);
  int bh = bm_h(bm_handle, 0);

  int dest_x = ((float)tpoint.x * (float)((float)bw / (float)w));
  int dest_y = ((float)tpoint.y * (float)((float)bh / (float)h));

  CreateElement(tpoint.x, tpoint.y);

  m_button_down = 1;

  CDialog::OnLButtonDown(nFlags, point);
}

void CWaterProceduralDialog::OnLButtonUp(UINT nFlags, CPoint point) {
  m_button_down = 0;
  CDialog::OnLButtonUp(nFlags, point);
}

void CWaterProceduralDialog::OnMouseMove(UINT nFlags, CPoint point) {
  CPoint tpoint = point;
  CWnd *texwnd;
  RECT rect;
  int n = D3EditState.texdlg_texture;

  if (m_button_down == 0)
    return;

  texwnd = GetDlgItem(IDC_WATER_PROCEDURAL_VIEW);
  texwnd->GetWindowRect(&rect);

  int w = rect.right - rect.left;
  int h = rect.bottom - rect.top;

  MapWindowPoints(texwnd, &tpoint, 1);

  if (tpoint.x < 0)
    return;
  if (tpoint.y < 0)
    return;

  if (tpoint.x >= w)
    return;
  if (tpoint.y >= h)
    return;

  if (m_proc_type != PROC_WATER_NONE)
    CreateElement(tpoint.x, tpoint.y);

  CDialog::OnMouseMove(nFlags, point);
}

// Creates a procedural element at x,y
static_proc_element *CWaterProceduralDialog::CreateElement(int x, int y) {
  int n = D3EditState.texdlg_texture;
  proc_struct *procedural = GameTextures[n].procedural;

  int index;

  if (GameTextures[n].procedural->num_static_elements >= MAX_PROC_ELEMENTS)
    return NULL;
  else
    index = GameTextures[n].procedural->num_static_elements;

  static_proc_element *proc_elem = &procedural->static_proc_elements[index];

  CWnd *texwnd;
  RECT rect;

  texwnd = GetDlgItem(IDC_WATER_PROCEDURAL_VIEW);
  texwnd->GetWindowRect(&rect);

  int w = rect.right - rect.left;
  int h = rect.bottom - rect.top;

  int bm_handle = GameTextures[n].procedural->procedural_bitmap;
  int bw = bm_w(bm_handle, 0);
  int bh = bm_h(bm_handle, 0);

  int dest_x = ((float)x * (float)((float)bw / (float)w));
  int dest_y = ((float)y * (float)((float)bh / (float)h));

  proc_elem->type = m_proc_type;

  proc_elem->x1 = dest_x;
  proc_elem->y1 = dest_y;
  proc_elem->size = m_size;
  proc_elem->speed = m_height;
  proc_elem->frequency = m_frequency;

  procedural->num_static_elements++;

  return &procedural->static_proc_elements[index];
}

void CWaterProceduralDialog::OnKillfocusProcEvalTimeEdit() {
  int n = D3EditState.texdlg_texture;

  CEdit *ebox;
  char name[20];
  float num = 0;

  ebox = (CEdit *)GetDlgItem(IDC_PROC_EVAL_TIME_EDIT);
  ebox->GetWindowText(name, 20);

  num = atof(name);
  if (num < 0)
    num = 0;
  if (num > 255)
    num = 255;

  GameTextures[n].procedural->evaluation_time = num;

  UpdateDialog();
}

void CWaterProceduralDialog::OnKillfocusProcOscTimeEdit() {
  int n = D3EditState.texdlg_texture;

  CEdit *ebox;
  char name[20];
  float num = 0;

  ebox = (CEdit *)GetDlgItem(IDC_PROC_OSC_TIME_EDIT);
  ebox->GetWindowText(name, 20);

  num = atof(name);
  if (num < 0)
    num = 0;
  if (num > 255)
    num = 255;

  GameTextures[n].procedural->osc_time = num;

  UpdateDialog();
}

void CWaterProceduralDialog::OnKillfocusProcOscValueEdit() {
  int n = D3EditState.texdlg_texture;

  CEdit *ebox;
  char name[20];
  int num = 0;

  ebox = (CEdit *)GetDlgItem(IDC_PROC_OSC_VALUE_EDIT);
  ebox->GetWindowText(name, 20);

  num = atoi(name);
  if (num < 0)
    num = 0;
  if (num > 200)
    num = 200;

  GameTextures[n].procedural->osc_value = num;

  UpdateDialog();
}

void CWaterProceduralDialog::OnCopyProcedural() {
  // get the name of the texture
  CComboBox *combo;
  CString str;
  int src_id;

  combo = (CComboBox *)GetDlgItem(IDC_PROC_COPY_LIST);
  combo->GetLBText(combo->GetCurSel(), str);
  src_id = FindTextureName(str.GetBuffer(0));
  ASSERT(src_id != -1);

  bool do_pal = false;
  char buffer[512];
  sprintf(buffer, "Are you sure you want to replace the procedural elements of %s with %s?",
          GameTextures[D3EditState.texdlg_texture].name, GameTextures[src_id].name);
  if (MessageBox(buffer, "Confirm", MB_YESNO) != IDYES)
    return;
  if (MessageBox("Would you like to replace the palette also?", "Palette", MB_YESNO) == IDYES)
    do_pal = true;

  mngs_texture_page src_page, dest_page;
  mng_AssignTextureToTexPage(src_id, &src_page);
  mng_AssignTextureToTexPage(D3EditState.texdlg_texture, &dest_page);

  ClearAllProceduralsFromTexture(D3EditState.texdlg_texture);
  FreeProceduralForTexture(D3EditState.texdlg_texture);

  int i;
  if (src_page.tex_struct.flags & TF_WATER_PROCEDURAL)
    dest_page.tex_struct.flags |= TF_WATER_PROCEDURAL;
  else
    dest_page.tex_struct.flags &= ~TF_WATER_PROCEDURAL;

  if (do_pal) {
    for (i = 0; i < 255; i++) {
      dest_page.proc_palette[i] = src_page.proc_palette[i];
    }
  }
  dest_page.proc_heat = src_page.proc_heat;
  dest_page.proc_light = src_page.proc_light;
  dest_page.proc_thickness = src_page.proc_thickness;
  dest_page.proc_evaluation_time = src_page.proc_evaluation_time;
  dest_page.osc_time = src_page.osc_time;
  dest_page.osc_value = src_page.osc_value;
  dest_page.num_proc_elements = src_page.num_proc_elements;

  for (i = 0; i < dest_page.num_proc_elements; i++) {
    dest_page.proc_type[i] = src_page.proc_type[i];
    dest_page.proc_frequency[i] = src_page.proc_frequency[i];
    dest_page.proc_speed[i] = src_page.proc_speed[i];
    dest_page.proc_size[i] = src_page.proc_size[i];
    dest_page.proc_x1[i] = src_page.proc_x1[i];
    dest_page.proc_y1[i] = src_page.proc_y1[i];
    dest_page.proc_x2[i] = src_page.proc_x2[i];
    dest_page.proc_y2[i] = src_page.proc_y2[i];
  }

  AllocateProceduralForTexture(D3EditState.texdlg_texture);
  AllocateStaticProceduralsForTexture(D3EditState.texdlg_texture, dest_page.num_proc_elements);
  GameTextures[D3EditState.texdlg_texture].procedural->num_static_elements = dest_page.num_proc_elements;
  GameTextures[D3EditState.texdlg_texture].procedural->heat = dest_page.proc_heat;
  GameTextures[D3EditState.texdlg_texture].procedural->light = dest_page.proc_light;
  GameTextures[D3EditState.texdlg_texture].procedural->thickness = dest_page.proc_thickness;
  GameTextures[D3EditState.texdlg_texture].procedural->evaluation_time = dest_page.proc_evaluation_time;
  GameTextures[D3EditState.texdlg_texture].procedural->osc_time = dest_page.osc_time;
  GameTextures[D3EditState.texdlg_texture].procedural->osc_value = dest_page.osc_value;

  // Last 2 colors are the same
  dest_page.proc_palette[255] = dest_page.proc_palette[254];
  memcpy(GameTextures[D3EditState.texdlg_texture].procedural->palette, dest_page.proc_palette, 256 * 2);

  for (i = 0; i < dest_page.num_proc_elements; i++) {
    static_proc_element *proc = &GameTextures[D3EditState.texdlg_texture].procedural->static_proc_elements[i];
    proc->type = dest_page.proc_type[i];
    proc->frequency = dest_page.proc_frequency[i];
    proc->speed = dest_page.proc_speed[i];
    proc->size = dest_page.proc_size[i];
    proc->x1 = dest_page.proc_x1[i];
    proc->y1 = dest_page.proc_y1[i];
    proc->x2 = dest_page.proc_x2[i];
    proc->y2 = dest_page.proc_y2[i];
  }

  UpdateDialog();
}