// EditMLRStateDlg.cpp : implementation file
//

#include "stdafx.h"
#include "PixelWhipPro.h"
#include "EditMLRStateDlg.h"
#include <MLR\MLRTexture.hpp>
#include <MLR\MLRTexturePool.hpp>


/////////////////////////////////////////////////////////////////////////////
// CEditMLRStateDlg dialog


CEditMLRStateDlg::CEditMLRStateDlg(CWnd* pParent /*=NULL*/)
: CDialog(CEditMLRStateDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CEditMLRStateDlg)
	m_AlphaList = -1;
	m_BackFaceList = -1;
	m_DitherList = -1;
	m_FilterList = -1;
	m_LightList = -1;
	m_TCorrectList = -1;
	m_TextureList = -1;
	m_ZBWriteList = -1;
	m_ZBCompareList = -1;
	m_WireFrameList = -1;
	m_FogList = -1;
	m_PriList = -1;
	m_PAlpha = FALSE;
	m_PBackFace = FALSE;
	m_PDither = FALSE;
	m_PFilter = FALSE;
	m_PFog = FALSE;
	m_PLight = FALSE;
	m_PPriority = FALSE;
	m_PTCorrect = FALSE;
	m_PTexture = FALSE;
	m_PWireFrame = FALSE;
	m_PZBWrite = FALSE;
	m_PZBCompare = FALSE;
	m_PColoring = FALSE;
	m_PSpecular = FALSE;
	m_ColoringList = -1;
	m_SpecularList = -1;
	//}}AFX_DATA_INIT
	States=NULL;
	LastState=-1;
}


void CEditMLRStateDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	
	
	//{{AFX_DATA_MAP(CEditMLRStateDlg)
	DDX_Control(pDX, IDC_STATELIST, m_StateList);
	DDX_Control(pDX, IDC_TEXTUREDSP, m_TextureText);
	DDX_CBIndex(pDX, IDC_ALPHALIST, m_AlphaList);
	DDX_CBIndex(pDX, IDC_BACKFACELIST, m_BackFaceList);
	DDX_CBIndex(pDX, IDC_DITHERLIST, m_DitherList);
	DDX_CBIndex(pDX, IDC_FILTERLIST, m_FilterList);
	DDX_CBIndex(pDX, IDC_LIGHTLIST, m_LightList);
	DDX_CBIndex(pDX, IDC_TCORRECTLIST, m_TCorrectList);
	DDX_CBIndex(pDX, IDC_TEXTURELIST, m_TextureList);
	DDX_CBIndex(pDX, IDC_ZBWRITELIST, m_ZBWriteList);
	DDX_CBIndex(pDX, IDC_ZBCOMPARELIST, m_ZBCompareList);
	DDX_CBIndex(pDX, IDC_WIREFRAMELIST, m_WireFrameList);
	DDX_CBIndex(pDX, IDC_FOGLIST, m_FogList);
	DDX_CBIndex(pDX, IDC_PRILEVEL, m_PriList);
	DDX_Check(pDX, IDC_PER_ALPHA, m_PAlpha);
	DDX_Check(pDX, IDC_PER_BACKFACE, m_PBackFace);
	DDX_Check(pDX, IDC_PER_DITHER, m_PDither);
	DDX_Check(pDX, IDC_PER_FILTER, m_PFilter);
	DDX_Check(pDX, IDC_PER_FOG, m_PFog);
	DDX_Check(pDX, IDC_PER_LIGHT, m_PLight);
	DDX_Check(pDX, IDC_PER_PRI, m_PPriority);
	DDX_Check(pDX, IDC_PER_TCORRECT, m_PTCorrect);
	DDX_Check(pDX, IDC_PER_TEXTURE, m_PTexture);
	DDX_Check(pDX, IDC_PER_WIREFRAME, m_PWireFrame);
	DDX_Check(pDX, IDC_PER_ZBWRI, m_PZBWrite);
	DDX_Check(pDX, IDC_PER_ZBCOM, m_PZBCompare);
	DDX_Check(pDX, IDC_PER_COLORING, m_PColoring);
	DDX_Check(pDX, IDC_PER_SPECULAR, m_PSpecular);
	DDX_CBIndex(pDX, IDC_COLORINGLIST, m_ColoringList);
	DDX_CBIndex(pDX, IDC_SPECULARLIST, m_SpecularList);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CEditMLRStateDlg, CDialog)
//{{AFX_MSG_MAP(CEditMLRStateDlg)
ON_BN_CLICKED(IDC_SAVEBUT, OnSavebut)
ON_LBN_SELCHANGE(IDC_STATELIST, OnSelchangeStatelist)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CEditMLRStateDlg message handlers

BOOL CEditMLRStateDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	CString tstr;
	int i;
	for(i=0;i<States->GetLength();i++)
	{
		tstr.Format("State#%i",i);
		m_StateList.InsertString(-1,tstr);
	} 
	
	
	LastState=0;
	m_StateList.SetCurSel(0);
	ReadState(0);
	return TRUE;  // return TRUE unless you set the focus to a control
	// EXCEPTION: OCX Property Pages should return FALSE
}

void CEditMLRStateDlg::ReadState(int stidx)
{
	Verify(stidx<States->GetLength());
	MidLevelRenderer::MLRState rstate;
	rstate=(*States)[stidx];
	MidLevelRenderer::MLRTexture *tex = NULL;
	
	if(rstate.GetTextureHandle() && ((tex = (*MidLevelRenderer::MLRTexturePool::Instance)[&rstate]) != NULL))
	{
		m_TextureText.SetWindowText(tex->GetTextureName());
	}
	else
		m_TextureText.SetWindowText("none");
	m_AlphaList=0;
	m_WireFrameList=0;
	m_FilterList=0;
	m_LightList=0;
	m_FogList=0;
	m_DitherList=0;
	m_TCorrectList=0;
	m_ZBWriteList=0;
	m_ZBCompareList=0;
	m_BackFaceList=0;
	m_PriList=0;
	m_SpecularList=0;
	m_ColoringList=0;
	
	int RDMask,PDMask;
	RDMask=rstate.GetRenderDeltaMask();
	PDMask=rstate.GetProcessDeltaMask();
	
	if(RDMask&MidLevelRenderer::MLRState::AlphaMask)
		switch(rstate.GetAlphaMode())
	{
	case MidLevelRenderer::MLRState::OneZeroMode:
		m_AlphaList=1;
		break;
	case MidLevelRenderer::MLRState::OneOneMode:
		m_AlphaList=2;
		break;
	case MidLevelRenderer::MLRState::AlphaOneMode:
		m_AlphaList=3;
		break;
	case MidLevelRenderer::MLRState::OneAlphaMode:
		m_AlphaList=4;
		break;
	case MidLevelRenderer::MLRState::AlphaInvAlphaMode:
		m_AlphaList=5;
		break;
	case MidLevelRenderer::MLRState::OneInvAlphaMode:
		m_AlphaList=6;
		break;
	}	
	
	if(RDMask&MidLevelRenderer::MLRState::WireFrameMask)
		switch(rstate.GetWireFrameMode())
	{
	case MidLevelRenderer::MLRState::WireFrameOffMode:
		m_WireFrameList=1;
		break;
	case MidLevelRenderer::MLRState::WireFrameOnlyMode:
		m_WireFrameList=2;
		break;
	case MidLevelRenderer::MLRState::WireFrameAddMode:
		m_WireFrameList=3;
		break;
	}
	
	if(RDMask&MidLevelRenderer::MLRState::FilterMask)
		switch(rstate.GetFilterMode())
	{
	case MidLevelRenderer::MLRState::NoFilterMode:
		m_FilterList=1;
		break;
	case MidLevelRenderer::MLRState::BiLinearFilterMode:
		m_FilterList=2;
		break;
	case MidLevelRenderer::MLRState::TriLinearFilterMode:
		m_FilterList=3;
		break;
	}
	
	if(PDMask&MidLevelRenderer::MLRState::LightingMask)	
	{
		if(	rstate.GetLightingMode()==MidLevelRenderer::MLRState::LightingOffMode)
			m_LightList=1;
		else
			if(	rstate.GetLightingMode()==(MidLevelRenderer::MLRState::VertexLightingMode|
				MidLevelRenderer::MLRState::FaceLightingMode|
				MidLevelRenderer::MLRState::LookupLightingMode))
				m_LightList=2;
			else
				if(	rstate.GetLightingMode()==(MidLevelRenderer::MLRState::VertexLightingMode|
					MidLevelRenderer::MLRState::FaceLightingMode))
					m_LightList=3;
				else
					if(	rstate.GetLightingMode()==(MidLevelRenderer::MLRState::LightMapLightingMode|
						MidLevelRenderer::MLRState::FaceLightingMode))
						m_LightList=4;
					else
						if(	rstate.GetLightingMode()==MidLevelRenderer::MLRState::LightMapLightingMode)
							m_LightList=5;
						else
							PAUSE(("Light Switch is in Invalid State"));
	}					
	
	
	if(RDMask&MidLevelRenderer::MLRState::FogMask)
		m_FogList=rstate.GetFogMode()+1;
	
	if(RDMask&MidLevelRenderer::MLRState::DitherMask)
		switch(rstate.GetDitherMode())
	{
	case MidLevelRenderer::MLRState::DitherOnMode:
		m_DitherList=1;
		break;
	case MidLevelRenderer::MLRState::DitherOffMode:
		m_DitherList=2;
		break;
	}
	
	if(RDMask&MidLevelRenderer::MLRState::TextureCorrectionMask)
		switch(rstate.GetTextureCorrectionMode())
	{
	case MidLevelRenderer::MLRState::TextureCorrectionOnMode:
		m_TCorrectList=1;
		break;
	case MidLevelRenderer::MLRState::TextureCorrectionOffMode:
		m_TCorrectList=2;
		break;
	}
	
	if(RDMask&MidLevelRenderer::MLRState::SpecularMask)
		switch(rstate.GetSpecularMode())
	{
	case MidLevelRenderer::MLRState::SpecularOnMode:
		m_SpecularList=1;
		break;
	case MidLevelRenderer::MLRState::SpecularOffMode:
		m_SpecularList=2;
		break;
	}
	
	if(RDMask&MidLevelRenderer::MLRState::FlatColoringMask)
		switch(rstate.GetFlatColoringMode())
	{
	case MidLevelRenderer::MLRState::FlatColoringOnMode:
		m_ColoringList=1;
		break;
	case MidLevelRenderer::MLRState::FlatColoringOffMode:
		m_ColoringList=2;
		break;
	}

		if(RDMask&MidLevelRenderer::MLRState::ZBufferCompareMask)
	switch(rstate.GetZBufferCompareMode())
	{
	case MidLevelRenderer::MLRState::ZBufferCompareOnMode:
		m_ZBCompareList=1;
		break;
	case MidLevelRenderer::MLRState::ZBufferCompareOffMode:
		m_ZBCompareList=2;
		break;
	}

		if(RDMask&MidLevelRenderer::MLRState::ZBufferWriteMask)
	switch(rstate.GetZBufferWriteMode())
	{
	case MidLevelRenderer::MLRState::ZBufferWriteOnMode:
		m_ZBWriteList=1;
		break;
	case MidLevelRenderer::MLRState::ZBufferWriteOffMode:
		m_ZBWriteList=2;
		break;
	}

	
	if(PDMask&MidLevelRenderer::MLRState::BackFaceMask)
		m_BackFaceList=(rstate.GetBackFaceMode()==MidLevelRenderer::MLRState::BackFaceOnMode)?1:2;
	
	if(PDMask&MidLevelRenderer::MLRState::PriorityMask)	
		m_PriList=rstate.GetPriority()+1;
	
	int PerMask;
	PerMask=rstate.GetRenderPermissionMask();
	
	
	m_PAlpha=(PerMask&MidLevelRenderer::MLRState::AlphaMask)?TRUE:FALSE;
	m_PTexture=(PerMask&MidLevelRenderer::MLRState::TextureMask)?TRUE:FALSE;
	m_PFilter=(PerMask&MidLevelRenderer::MLRState::FilterMask)?TRUE:FALSE;
	m_PWireFrame=(PerMask&MidLevelRenderer::MLRState::WireFrameMask)?TRUE:FALSE;
	m_PFog=(PerMask&MidLevelRenderer::MLRState::FogMask)?TRUE:FALSE;
	m_PDither=(PerMask&MidLevelRenderer::MLRState::DitherMask)?TRUE:FALSE;
	m_PTCorrect=(PerMask&MidLevelRenderer::MLRState::TextureCorrectionMask)?TRUE:FALSE;
	m_PSpecular=(PerMask&MidLevelRenderer::MLRState::SpecularMask)?TRUE:FALSE;
	m_PColoring=(PerMask&MidLevelRenderer::MLRState::FlatColoringMask)?TRUE:FALSE;
	m_PZBCompare=(PerMask&MidLevelRenderer::MLRState::ZBufferCompareMask)?TRUE:FALSE;
	m_PZBWrite=(PerMask&MidLevelRenderer::MLRState::ZBufferWriteMask)?TRUE:FALSE;
	
	m_PLight=(rstate.GetProcessPermissionMask()&MidLevelRenderer::MLRState::LightingMask)?TRUE:FALSE;
	m_PBackFace=(rstate.GetProcessPermissionMask()&MidLevelRenderer::MLRState::BackFaceMask)?TRUE:FALSE;
	m_PPriority=(rstate.GetProcessPermissionMask()&MidLevelRenderer::MLRState::PriorityMask)?TRUE:FALSE;
	
	
	UpdateData(FALSE);
}

void CEditMLRStateDlg::OnSavebut() 
{
	UpdateState(m_StateList.GetCurSel());
	CDialog::OnOK();
}

void CEditMLRStateDlg::OnOK() 
{
	//	CDialog::OnOK();
}


void CEditMLRStateDlg::UpdateState(int idx)
{
	Verify(idx<States->GetLength());
	MidLevelRenderer::MLRState rstate;
	rstate=(*States)[idx];
	
	
	
	UpdateData(TRUE);
	//Set Delta Masks
	int RDMask,PDMask;
	RDMask=rstate.GetRenderDeltaMask();
	
	//	RDMask|=MidLevelRenderer::MLRState::TextureMask;
	RDMask|=MidLevelRenderer::MLRState::ZBufferCompareMask;
	RDMask|=MidLevelRenderer::MLRState::ZBufferWriteMask;
	RDMask|=MidLevelRenderer::MLRState::FilterMask;
	RDMask|=MidLevelRenderer::MLRState::WireFrameMask;
	RDMask|=MidLevelRenderer::MLRState::FogMask;
	RDMask|=MidLevelRenderer::MLRState::DitherMask;
	RDMask|=MidLevelRenderer::MLRState::TextureCorrectionMask;
	RDMask|=MidLevelRenderer::MLRState::SpecularMask;
	RDMask|=MidLevelRenderer::MLRState::FlatColoringMask;
	
	PDMask=rstate.GetProcessDeltaMask();
	PDMask|=MidLevelRenderer::MLRState::LightingMask;
	PDMask|=MidLevelRenderer::MLRState::BackFaceMask;
	PDMask|=MidLevelRenderer::MLRState::PriorityMask;
	
	//	RDMask=RDMask&~MidLevelRenderer::MLRState::TextureMask;
	
	
	switch(m_AlphaList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 1:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::OneZeroMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 2:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::OneOneMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 3:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::AlphaOneMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 4:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::OneAlphaMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 5:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::AlphaInvAlphaMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	case 6:
		rstate.SetAlphaMode(MidLevelRenderer::MLRState::OneInvAlphaMode);
		RDMask|=MidLevelRenderer::MLRState::AlphaMask;
		break;
	}
	
	
	switch(m_WireFrameList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::WireFrameMask;
		break;
	case 1:
		rstate.SetWireFrameMode(MidLevelRenderer::MLRState::WireFrameOffMode);
		RDMask|=MidLevelRenderer::MLRState::WireFrameMask;
		break;
	case 2:
		rstate.SetWireFrameMode(MidLevelRenderer::MLRState::WireFrameOnlyMode);
		RDMask|=MidLevelRenderer::MLRState::WireFrameMask;
		break;
	case 3:
		rstate.SetWireFrameMode(MidLevelRenderer::MLRState::WireFrameAddMode);
		RDMask|=MidLevelRenderer::MLRState::WireFrameMask;
		break;
	}
	
	switch(m_FilterList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::FilterMask;
		break;
	case 1:
		rstate.SetFilterMode(MidLevelRenderer::MLRState::NoFilterMode);
		RDMask|=MidLevelRenderer::MLRState::FilterMask;
		break;
	case 2:
		rstate.SetFilterMode(MidLevelRenderer::MLRState::BiLinearFilterMode);
		RDMask|=MidLevelRenderer::MLRState::FilterMask;
		break;
	case 3:
		rstate.SetFilterMode(MidLevelRenderer::MLRState::TriLinearFilterMode);
		RDMask|=MidLevelRenderer::MLRState::FilterMask;
		break;
	}
	
	
	switch(m_LightList)
	{
	case 0:
		PDMask=PDMask^MidLevelRenderer::MLRState::LightingMask;
		break;
	case 1:
		rstate.SetLightingMode(MidLevelRenderer::MLRState::LightingOffMode);
		PDMask|=MidLevelRenderer::MLRState::LightingMask;
		break;
	case 2:
		rstate.SetLightingMode(	MidLevelRenderer::MLRState::VertexLightingMode|
			MidLevelRenderer::MLRState::FaceLightingMode|
			MidLevelRenderer::MLRState::LookupLightingMode);
		PDMask|=MidLevelRenderer::MLRState::LightingMask;
		break;
	case 3:
		rstate.SetLightingMode(MidLevelRenderer::MLRState::VertexLightingMode|
			MidLevelRenderer::MLRState::FaceLightingMode
			);
		PDMask|=MidLevelRenderer::MLRState::LightingMask;
		break;
	case 4:
		rstate.SetLightingMode(MidLevelRenderer::MLRState::LightMapLightingMode|
			MidLevelRenderer::MLRState::FaceLightingMode);
		PDMask|=MidLevelRenderer::MLRState::LightingMask;
		break;
	case 5:
		rstate.SetLightingMode(MidLevelRenderer::MLRState::LightMapLightingMode);
		PDMask|=MidLevelRenderer::MLRState::LightingMask;
		break;
	}
	
	if(m_FogList==0)
	{
		RDMask=RDMask&~MidLevelRenderer::MLRState::FogMask;
	}
	else
	{
		rstate.SetFogMode(m_FogList-1);
		RDMask|=MidLevelRenderer::MLRState::FogMask;
	}
	
	switch(m_DitherList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::DitherMask;
		break;
	case 1:
		rstate.SetDitherOn();
		RDMask|=MidLevelRenderer::MLRState::DitherMask;
		break;
	case 2:
		rstate.SetDitherOff();
		RDMask|=MidLevelRenderer::MLRState::DitherMask;
		break;
	}
	
	
	switch(m_TCorrectList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::TextureCorrectionMask;
		break;
	case 1:
		rstate.SetTextureCorrectionOn();
		RDMask|=MidLevelRenderer::MLRState::TextureCorrectionMask;
		break;
	case 2:
		rstate.SetTextureCorrectionOff();
		RDMask|=MidLevelRenderer::MLRState::TextureCorrectionMask;
		break;
	}
	
	switch(m_SpecularList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::SpecularMask;
		break;
	case 1:
		rstate.SetSpecularOn();
		RDMask|=MidLevelRenderer::MLRState::SpecularMask;
		break;
	case 2:
		rstate.SetSpecularOff();
		RDMask|=MidLevelRenderer::MLRState::SpecularMask;
		break;
	}
	
	switch(m_ColoringList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::FlatColoringMask;
		break;
	case 1:
		rstate.SetFlatColoringOn();
		RDMask|=MidLevelRenderer::MLRState::FlatColoringMask;
		break;
	case 2:
		rstate.SetFlatColoringOff();
		RDMask|=MidLevelRenderer::MLRState::FlatColoringMask;
		break;
	}
	
	
	switch(m_ZBCompareList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::ZBufferCompareMask;
		break;
	case 1:
		rstate.SetZBufferCompareOn();
		RDMask|=MidLevelRenderer::MLRState::ZBufferCompareMask;
		break;
	case 2:
		rstate.SetZBufferCompareOff();
		RDMask|=MidLevelRenderer::MLRState::ZBufferCompareMask;
	}

	switch(m_ZBWriteList)
	{
	case 0:
		RDMask=RDMask&~MidLevelRenderer::MLRState::ZBufferWriteMask;
		break;
	case 1:
		rstate.SetZBufferWriteOn();
		RDMask|=MidLevelRenderer::MLRState::ZBufferWriteMask;
		break;
	case 2:
		rstate.SetZBufferWriteOff();
		RDMask|=MidLevelRenderer::MLRState::ZBufferWriteMask;
	}



	switch(m_BackFaceList)
	{
	case 0:
		PDMask=PDMask^MidLevelRenderer::MLRState::BackFaceMask;
		break;
	case 1:
		rstate.SetBackFaceOn();
		PDMask|=MidLevelRenderer::MLRState::BackFaceMask;
		break;
	case 2:
		rstate.SetBackFaceOff();
		PDMask|=MidLevelRenderer::MLRState::BackFaceMask;
		break;
	}
	
	if(m_PriList!=0)
	{
		rstate.SetPriority(m_PriList-1);
		PDMask|=MidLevelRenderer::MLRState::PriorityMask;
	}
	else
	{
		PDMask=PDMask^MidLevelRenderer::MLRState::PriorityMask;
	}
	
	rstate.SetRenderDeltaMask(RDMask);
	rstate.SetProcessDeltaMask(PDMask);
	
	
	//Set Permission Masks
	
	
	RDMask=rstate.GetRenderPermissionMask();
	
	RDMask=RDMask&~MidLevelRenderer::MLRState::TextureMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::ZBufferCompareMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::ZBufferWriteMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::AlphaMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::FilterMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::WireFrameMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::FogMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::DitherMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::TextureCorrectionMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::SpecularMask;
	RDMask=RDMask&~MidLevelRenderer::MLRState::FlatColoringMask;
	
	
	RDMask|=m_PTexture?MidLevelRenderer::MLRState::TextureMask:0;
	RDMask|=m_PZBCompare?MidLevelRenderer::MLRState::ZBufferCompareMask:0;
	RDMask|=m_PZBWrite?MidLevelRenderer::MLRState::ZBufferWriteMask:0;
	RDMask|=m_PAlpha?MidLevelRenderer::MLRState::AlphaMask:0;
	RDMask|=m_PFilter?MidLevelRenderer::MLRState::FilterMask:0;
	RDMask|=m_PWireFrame?MidLevelRenderer::MLRState::WireFrameMask:0;
	RDMask|=m_PFog?MidLevelRenderer::MLRState::FogMask:0;
	RDMask|=m_PDither?MidLevelRenderer::MLRState::DitherMask:0;
	RDMask|=m_PTCorrect?MidLevelRenderer::MLRState::TextureCorrectionMask:0;
	RDMask|=m_PSpecular?MidLevelRenderer::MLRState::SpecularMask:0;
	RDMask|=m_PColoring?MidLevelRenderer::MLRState::FlatColoringMask:0;
	
	rstate.SetRenderPermissionMask(RDMask);
	
	PDMask=rstate.GetProcessPermissionMask();
	
	
	PDMask=PDMask&~MidLevelRenderer::MLRState::LightingMask;
	PDMask=PDMask&~MidLevelRenderer::MLRState::BackFaceMask;
	PDMask=PDMask&~MidLevelRenderer::MLRState::PriorityMask;
	
	PDMask|=m_PLight?MidLevelRenderer::MLRState::LightingMask:0;
	PDMask|=m_PBackFace?MidLevelRenderer::MLRState::BackFaceMask:0;
	PDMask|=m_PPriority?MidLevelRenderer::MLRState::PriorityMask:0;
	
	rstate.SetProcessPermissionMask(PDMask);
	
	
	(*States)[idx]=rstate;
}

void CEditMLRStateDlg::SetStates(Stuff::DynamicArrayOf<MidLevelRenderer::MLRState> *stt)
{
	States=stt;
}

void CEditMLRStateDlg::OnSelchangeStatelist() 
{
	UpdateState(LastState);
	ReadState(m_StateList.GetCurSel());
	
}