ben/CnC_Renegade
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Renegade.git synced 2026-02-04 07:53:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit of Command & Conquer Renegade source code.

Browse Source
This commit is contained in:
LFeenanEA
2025-02-27 16:39:46 +00:00
parent 74ab8fa5e0
commit 58ed459113
4918 changed files with 1366710 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

273
Code/Tools/LevelEdit/HistogramCtl.h Normal file
View File

@@ -0,0 +1,273 @@
/*
** 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 : LevelEdit *
* *
* $Archive:: /Commando/Code/Tools/LevelEdit/HistogramCtl.h $Modtime:: 7/2/99 6:28p $*
* *
* $Revision:: 3 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef __HISTOGRAM_CTL_H
#define __HISTOGRAM_CTL_H
#include "Vector.H"
#include "Vector3.H"
///////////////////////////////////////////////////////////////////
//
// HistogramCtlClass
//
///////////////////////////////////////////////////////////////////
class HistogramCtlClass
{
public:
//////////////////////////////////////////////////////////////
// Public constructors/destructors
//////////////////////////////////////////////////////////////
HistogramCtlClass (void);
virtual ~HistogramCtlClass (void);
//////////////////////////////////////////////////////////////
// Public methods
//////////////////////////////////////////////////////////////
void Add_Data_Point (float value);
void Reset_Data_Points (void);
// Selection managment
void Get_Selection (float &range_min, float &range_max);
void Set_Selection (float range_min, float range_max);
void Set_Selection (int min_pixel, int max_pixel);
void Clear_Selection (void);
// Control customization
void Set_X_Axis_Range (float min, float max);
void Set_Y_Axis_Range (float min, float max);
void Set_Dimensions (int width, int height);
void Set_Bk_Color (const Vector3 &low, const Vector3 &high);
void Set_Color (const Vector3 &low, const Vector3 &high);
// Painting methods
bool Is_Dirty (void) const { return m_IsDirty; }
void Set_Dirty (bool dirty = true);
void Allow_Refresh (bool onoff = true);
void Render (HDC hdc, int x_pos, int y_pos);
protected:
//////////////////////////////////////////////////////////////
// Protected methods
//////////////////////////////////////////////////////////////
void Create_DIB_Section (void);
void Destroy_DIB_Section (void);
void Paint_DIB (void);
int Find_Value_Index (float value);
private:
//////////////////////////////////////////////////////////////
// Private data types
//////////////////////////////////////////////////////////////
typedef struct
{
float min;
float max;
} RANGE;
typedef struct _VALUE
{
// Data members
float value;
int count;
// For DynamicVectorClass
_VALUE (void) : value (0), count (0) { }
_VALUE (float _value, DWORD _count) : value (_value), count (_count) { }
bool operator== (const _VALUE &src) { return false; }
bool operator!= (const _VALUE &src) { return true; }
} VALUE;
typedef DynamicVectorClass<VALUE> VALUE_LIST;
//////////////////////////////////////////////////////////////
// Private member data
//////////////////////////////////////////////////////////////
HBITMAP m_hBitmap;
unsigned char *m_pBits;
int m_ScanlineSize;
int m_BMPWidth;
int m_BMPHeight;
bool m_IsDirty;
bool m_AllowRefresh;
Vector3 m_BkLowColor;
Vector3 m_BkHighColor;
Vector3 m_LowColor;
Vector3 m_HighColor;
Vector3 m_SelColor;
Vector3 m_BkSelColor;
RANGE m_XAxis;
RANGE m_YAxis;
RANGE m_Selection;
VALUE_LIST m_ValueList;
};
inline void
HistogramCtlClass::Set_X_Axis_Range (float min, float max)
{
m_XAxis.min = min;
m_XAxis.max = max;
Set_Dirty (true);
return ;
}
inline void
HistogramCtlClass::Set_Y_Axis_Range (float min, float max)
{
m_YAxis.min = min;
m_YAxis.max = max;
Set_Dirty (true);
return ;
}
inline void
HistogramCtlClass::Clear_Selection (void)
{
m_Selection.min = -1;
m_Selection.max = -1;
Set_Dirty (true);
return ;
}
inline void
HistogramCtlClass::Set_Selection (int min_pixel, int max_pixel)
{
float x_range = m_XAxis.max - m_XAxis.min;
//int start_index = Find_Value_Index (m_XAxis.min);
//int end_index = Find_Value_Index (m_XAxis.max);
/*float *x_vector = new float[m_BMPWidth*2];
::memset (x_vector, 0, sizeof (float) * m_BMPWidth * 2);
if (m_ValueList[)
//
// Loop through all the values and combine pixel-duplicates
//
for (int index = start_index; index <= end_index; index ++) {
VALUE &value = m_ValueList[index];
int x_pos = int((value.value / x_range) * (float)(m_BMPWidth-1));
x_vector[x_pos] = min (x_vector[x_pos], value.value);
x_vector[x_pos*2] = max (x_vector[x_pos*2], value.value);
}
//float value1 = ((float)(min_pixel * x_range) / ((float)m_BMPWidth));
//float value2 = ((float)(max_pixel * x_range) / ((float)m_BMPWidth));
float value1 = x_vector[min_pixel];
float value2 = x_vector[max_pixel*2];
delete [] x_vector;*/
float pixel_range = x_range / (float)m_BMPWidth;
float left = min_pixel * pixel_range;
float right = (max_pixel + 1) * pixel_range;
float value1 = m_XAxis.min + left;
float value2 = m_XAxis.min + right;
m_Selection.min = min (value1, value2);
m_Selection.max = max (value1, value2);
/*if (min_pixel != -1) {
m_Selection.min = min (value1, value2);
}
if (max_pixel != -1) {
m_Selection.max = max (value1, value2);
}*/
/*float real_min = min (value1, value2);
float real_max = max (value1, value2);
m_Selection.min = min (m_Selection.min, real_min);
m_Selection.max = max (m_Selection.max, real_max);*/
Set_Dirty (true);
return ;
}
inline void
HistogramCtlClass::Set_Selection (float min, float max)
{
m_Selection.min = min;
m_Selection.max = max;
Set_Dirty (true);
return ;
}
inline void
HistogramCtlClass::Get_Selection (float &min, float &max)
{
min = m_Selection.min;
max = m_Selection.max;
return ;
}
inline void
HistogramCtlClass::Set_Dirty (bool dirty)
{
m_IsDirty = dirty;
return ;
}
inline void
HistogramCtlClass::Allow_Refresh (bool onoff)
{
m_AllowRefresh = onoff;
return ;
}
#endif //__HISTOGRAM_CTL_H