internal_highlevel.h

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(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/>.
*/

// $File: //depot/GeneralsMD/Staging/code/Libraries/Source/profile/internal_highlevel.h $
// $Author: mhoffe $
// $Revision: #2 $
// $DateTime: 2003/08/14 13:43:29 $
//
// ©2003 Electronic Arts
//
// High level profiling (internal header)
#ifdef _MSC_VER
#  pragma once
#endif
#ifndef INTERNAL_HIGHLEVEL_H // Include guard
#define INTERNAL_HIGHLEVEL_H

class ProfileId
{
  ProfileId(const ProfileId&);
  ProfileId& operator=(const ProfileId&);
 
public:
  ProfileId(const char *name, const char *descr, const char *unit, int precision, int exp10);

  static ProfileId *GetFirst(void) { return first; }

  ProfileId *GetNext(void) const { return m_next; }

  const char *GetName(void) const { return m_name; }

  const char *GetUnit(void) const { return m_unit?m_unit:""; }

  const char *GetDescr(void) const { return m_descr?m_descr:""; }

  void Increment(double add);

  void Maximum(double max);

  double GetCurrentValue(void)
  {
    double help=m_curVal;
    m_curVal=0.;
    return help;
  }

  double GetTotalValue(void) const
  {
    return m_totalVal;
  }

  bool GetFrameValue(unsigned frame, double &value) const
  {
    if (frame<(unsigned)m_firstFrame||
        frame>=(unsigned)curFrame)
      return false;
    value=m_recFrameVal[frame-m_firstFrame];
    return true;
  }

  const char *AsString(double v) const;

  static void Shutdown(void);

  static int FrameStart(void);

  static void FrameEnd(int which, int mixIndex);

  static void ClearTotals(void)
  {
    for (ProfileId *cur=first;cur;cur=cur->m_next)
      cur->m_totalVal=0.;
  }
 
private:
  ~ProfileId() {}
  
  enum
  {
    MAX_FRAME_RECORDS = 4,

    STRING_BUFFER_SIZE = 1024
  };

  enum ValueMode
  {
    Unknown,
    ModeIncrement,
    ModeMaximum
  };

  static ProfileId *first;

  ProfileId *m_next;

  char *m_name;

  char *m_descr;

  char *m_unit;

  int m_precision;

  int m_exp10;

  double m_curVal;

  double m_totalVal;

  double m_frameVal[MAX_FRAME_RECORDS];

  double *m_recFrameVal;

  int m_firstFrame;

  ValueMode m_valueMode;

  static int curFrame;

  static unsigned frameRecordMask;

  static char stringBuf[STRING_BUFFER_SIZE];

  static unsigned stringBufUnused;
};
 
#endif // INTERNAL_HIGHLEVEL_H