scenestate.cpp

activate your member account after checking your files. If

   pEffect->SetValue("iLightSpotIni", (void*)&iSpotIni, sizeof(int));
   pEffect->SetValue("iLightSpotNum", (void*)&iSpotNum, sizeof(int));

   //set up automatic texture generation
   pEffect->SetValue("iTexType", (void*)&m_tex.iTexType, sizeof(int));
   pEffect->SetValue("iTexGenType", (void*)&m_tex.iTexGenType, sizeof(int));
}

//-----------------------------------------------------------------------------
// Name: InitFromEffects()
// Desc: Reads the settings from the effect
//-----------------------------------------------------------------------------
void CSceneState::InitFromEffects(LPD3DXEFFECT pEffect)
{
   int i;
   int itmp;
   char tmp[64];
   m_bInited = true;

   // Misc
   pEffect->GetValue("vAmbientColor", (void*)&m_vAmbientColor, sizeof(D3DCOLORVALUE));
   pEffect->GetValue("vMaterialColor", (void*)&m_vMaterialColor, sizeof(D3DCOLORVALUE));
   pEffect->GetValue("fMaterialPower", (void*)&m_fMaterialPower, sizeof(FLOAT));
   pEffect->GetBool("bSpecular", &itmp);
   m_bSpecular = (itmp == 1 ? true : false);
   pEffect->GetBool("bTweening", &itmp);
   m_bTweening = (itmp == 1 ? true : false);

   // Fog
   pEffect->GetValue("iFogType", (void*)&m_vfog.iType, sizeof(int));
   pEffect->GetValue("vFogColor", (void*)&m_vfog.vColor, sizeof(D3DCOLORVALUE));
   pEffect->GetValue("fFogStart", (void*)&m_vfog.fStart, sizeof(float));
   pEffect->GetValue("fFogEnd", (void*)&m_vfog.fEnd, sizeof(float));
   pEffect->GetValue("fFogDensity", (void*)&m_vfog.fDensity, sizeof(float));
   pEffect->GetBool("bFogRange", &itmp);
   m_vfog.bRange = (itmp == 1 ? true : false);

   // Set up lighting states
   for(i = 0; i < NUM_LIGHTS; i++)
   {
      sprintf(tmp, "lights[%i].iType", i);
      pEffect->GetValue(tmp, (void*)&m_iLightType[i], sizeof(int));
      sprintf(tmp, "lights[%i].vPos", i);
      pEffect->GetValue(tmp, (void*)&m_light[i].Position, sizeof(D3DVECTOR));
      sprintf(tmp, "lights[%i].vDir", i);
      pEffect->GetValue(tmp, (void*)&m_light[i].Direction, sizeof(D3DVECTOR));
      sprintf(tmp, "lights[%i].vAmbient", i);
      pEffect->GetValue(tmp, (void*)&m_light[i].Ambient, sizeof(D3DCOLORVALUE));
      sprintf(tmp, "lights[%i].vDiffuse", i);
      pEffect->GetValue(tmp, (void*)&m_light[i].Diffuse, sizeof(D3DCOLORVALUE));
      sprintf(tmp, "lights[%i].vSpecular", i);
      pEffect->GetValue(tmp, (void*)&m_light[i].Specular, sizeof(D3DCOLORVALUE));

      float vAttenuation[4];
      sprintf(tmp, "lights[%i].vAttenuation", i);
      pEffect->GetValue(tmp, (void*)&vAttenuation, sizeof(float)*4);
      m_light[i].Attenuation0 = vAttenuation[0];
      m_light[i].Attenuation1 = vAttenuation[1];
      m_light[i].Attenuation2 = vAttenuation[2];
      m_light[i].Range = vAttenuation[3];
      float vSpot[3];
      sprintf(tmp, "lights[%i].vSpot", i);
      pEffect->GetValue(tmp, (void*)&vSpot, sizeof(float)*3);
      m_light[i].Theta = (float)acos(vSpot[0])*2.f;
      m_light[i].Phi = (float)acos(vSpot[1])*2.f;
      m_light[i].Falloff = vSpot[2];
   }

   //automatic texture generation
   pEffect->GetValue("iTexType", (void*)&m_tex.iTexType, sizeof(int));
   pEffect->GetValue("iTexGenType", (void*)&m_tex.iTexGenType, sizeof(int));
}

//-----------------------------------------------------------------------------
// Name: Change()
// Desc: Called to change state settings
//-----------------------------------------------------------------------------
void CSceneState::Change(int iParam, int &iParamLight, int iDirection, 
                            bool bChangeFast, HWND hWnd, bool *pbReInitAll)
{
   float fChange = ((float)iDirection) * (bChangeFast ? 1.f : .01f);
   switch(iParam)
   {
      case PARAM_AMBIENT_COLOR:
         ColorPick(hWnd, &m_vAmbientColor);
         break;
      case PARAM_MATERIAL_COLOR:
         ColorPick(hWnd, &m_vMaterialColor);
         break;
      case PARAM_MATERIAL_POWER:
         m_fMaterialPower += fChange;
         if(m_fMaterialPower < 0.f)
            m_fMaterialPower = 0.f;
         break;
      case PARAM_SPECULAR_ENABLE:
         m_bSpecular = !m_bSpecular;
         break;
      case PARAM_TWEENING_ENABLE:
         m_bTweening = !m_bTweening;
         *pbReInitAll = true;
         break;
      case PARAM_FOG_TYPE:
         m_vfog.iType = (m_vfog.iType + iDirection + FOG_NUM_TYPES) % FOG_NUM_TYPES;
         break;
      case PARAM_FOG_COLOR:
         ColorPick(hWnd, &m_vfog.vColor);
         break;
      case PARAM_FOG_START:
         m_vfog.fStart += fChange;
         if(m_vfog.fStart < 0.f)
            m_vfog.fStart = 0.f;
         if(m_vfog.fStart > m_vfog.fEnd)
            m_vfog.fStart = m_vfog.fEnd;
         break;
      case PARAM_FOG_END:
         m_vfog.fEnd += fChange;
         if(m_vfog.fEnd < m_vfog.fStart)
            m_vfog.fEnd = m_vfog.fStart;
         break;
      case PARAM_FOG_DENSITY:
         m_vfog.fDensity += fChange;
         if(m_vfog.fDensity < 0.f)
            m_vfog.fDensity = 0.f;
         break;
      case PARAM_FOG_RANGE:
         m_vfog.bRange = !m_vfog.bRange;
         break;
      case PARAM_LIGHT_NUM:
         iParamLight = (iParamLight + iDirection + NUM_LIGHTS) % NUM_LIGHTS;
         break;
      case PARAM_LIGHT_TYPE:
         m_iLightType[iParamLight] = (m_iLightType[iParamLight] + iDirection + LIGHT_NUM_TYPES) % LIGHT_NUM_TYPES;
         iParamLight = SortLights(iParamLight);
         break;
      case PARAM_LIGHT_POS_X:
         m_light[iParamLight].Position.x += fChange;
         break;
      case PARAM_LIGHT_POS_Y:
         m_light[iParamLight].Position.y += fChange;
         break;
      case PARAM_LIGHT_POS_Z:
         m_light[iParamLight].Position.z += fChange;
         break;
      case PARAM_LIGHT_DIR_X:
         m_light[iParamLight].Direction.x += fChange;
         break;
      case PARAM_LIGHT_DIR_Y:
         m_light[iParamLight].Direction.y += fChange;
         break;
      case PARAM_LIGHT_DIR_Z:
         m_light[iParamLight].Direction.z += fChange;
         break;
      case PARAM_LIGHT_AMBIENT:
         ColorPick(hWnd, &m_light[iParamLight].Ambient);
         break;
      case PARAM_LIGHT_DIFFUSE:
         ColorPick(hWnd, &m_light[iParamLight].Diffuse);
         break;
      case PARAM_LIGHT_SPECULAR:
         ColorPick(hWnd, &m_light[iParamLight].Specular);
         break;
      case PARAM_LIGHT_RANGE:
         m_light[iParamLight].Range += fChange;
         if(m_light[iParamLight].Range < 0.f)
            m_light[iParamLight].Range = 0.f;
         break;
      case PARAM_LIGHT_FALLOFF:
         m_light[iParamLight].Falloff += fChange;
         if(m_light[iParamLight].Falloff < 0.f)
            m_light[iParamLight].Falloff = 0.f;
         break;
      case PARAM_LIGHT_ATTENUATION0:
         m_light[iParamLight].Attenuation0 += fChange;
         if(m_light[iParamLight].Attenuation0 < 0.f)
            m_light[iParamLight].Attenuation0 = 0.f;
         break;
      case PARAM_LIGHT_ATTENUATION1:
         m_light[iParamLight].Attenuation1 += fChange;
         if(m_light[iParamLight].Attenuation1 < 0.f)
            m_light[iParamLight].Attenuation1 = 0.f;
         break;
      case PARAM_LIGHT_ATTENUATION2:
         m_light[iParamLight].Attenuation2 += fChange;
         if(m_light[iParamLight].Attenuation2 < 0.f)
            m_light[iParamLight].Attenuation2 = 0.f;
         break;
      case PARAM_LIGHT_THETA:
         m_light[iParamLight].Theta += fChange;
         if(m_light[iParamLight].Theta < 0)
            m_light[iParamLight].Theta = 0;
         if(m_light[iParamLight].Theta > m_light[iParamLight].Phi)
            m_light[iParamLight].Theta = m_light[iParamLight].Phi;
         break;
      case PARAM_LIGHT_PHI:
         m_light[iParamLight].Phi += fChange;
         if(m_light[iParamLight].Phi < m_light[iParamLight].Theta)
            m_light[iParamLight].Phi = m_light[iParamLight].Theta;
         break;
      case PARAM_TEX_TYPE:
         m_tex.iTexType = (m_tex.iTexType + iDirection + TEX_NUM_TYPES) % TEX_NUM_TYPES;
         break;
      case PARAM_TEXGEN_TYPE:
         m_tex.iTexGenType = (m_tex.iTexGenType + iDirection + TEXGEN_NUM_TYPES) % TEXGEN_NUM_TYPES;
         break;
   }
}

//-----------------------------------------------------------------------------
// Name: ColorPick()
// Desc: Lets user pick color
//-----------------------------------------------------------------------------
void CSceneState::ColorPick(HWND hWnd, D3DCOLORVALUE *rgbColor)
{
   CHOOSECOLOR cc;
   COLORREF    crCustColors[16];
   COLORREF    rgb;
   BYTE        red, green, blue;

   red   = (BYTE) ((rgbColor->r) * 255.0f);
   green = (BYTE) ((rgbColor->g) * 255.0f);
   blue  = (BYTE) ((rgbColor->b) * 255.0f);

   rgb = RGB(red, green, blue);

   cc.lStructSize		= sizeof(CHOOSECOLOR);
   cc.hwndOwner		= hWnd;
   cc.hInstance		= hWnd;
   cc.rgbResult		= rgb;
   cc.lpCustColors	= crCustColors;
   cc.Flags			   = CC_RGBINIT | CC_FULLOPEN;
   cc.lCustData		= 0l;
   cc.lpfnHook			= NULL;
   cc.lpTemplateName	= NULL;

   if(ChooseColor(&cc))
   {
      rgbColor->r = (FLOAT) (GetRValue(cc.rgbResult) / 255.0f);
      rgbColor->g = (FLOAT) (GetGValue(cc.rgbResult) / 255.0f);
      rgbColor->b = (FLOAT) (GetBValue(cc.rgbResult) / 255.0f);
   }
}

//structure for light sorting function
struct SortStruct
{
   int iValue;
   int iPosition;
};

//the comparision function for the sort
int sortfunc(const void *a, const void *b)
{
   int ia = ((SortStruct *)a)->iValue;
   int ib = ((SortStruct *)b)->iValue;
   if(ia < ib)
      return -1;
   else if(ia > ib)
      return 1;
   else
      return 0;
}

//-----------------------------------------------------------------------------
// Name: SortLights()
// Desc: Sorts the lights. This is necessary to make sure the spot lights
//       follow the point lights. It takes the index of the currently selected
//       light as an argument and returns its new position
//-----------------------------------------------------------------------------
int CSceneState::SortLights(int iCurrent)
{
   int iCurrentNew;
   SortStruct sortee[NUM_LIGHTS];
   for(int i = 0; i < NUM_LIGHTS; i++)
   {
      switch(m_iLightType[i])
      {
      case LIGHT_TYPE_DIRECTIONAL:
         sortee[i].iValue = i;
         break;
      case LIGHT_TYPE_POINT:
         sortee[i].iValue = NUM_LIGHTS+i;
         break;
      case LIGHT_TYPE_SPOT:
         sortee[i].iValue = 2*NUM_LIGHTS+i;
         break;
      case LIGHT_TYPE_NONE:
         sortee[i].iValue = 3*NUM_LIGHTS+i;
         break;
      }
      sortee[i].iPosition = i;
   }
   qsort(sortee, NUM_LIGHTS, sizeof(SortStruct), sortfunc);
   int iTypes[NUM_LIGHTS];
   D3DLIGHT9 lights[NUM_LIGHTS];
   memcpy(iTypes, m_iLightType, sizeof(int)*NUM_LIGHTS);
   memcpy(lights, m_light, sizeof(D3DLIGHT9)*NUM_LIGHTS);
   for(i = 0; i < NUM_LIGHTS; i++)
   {
      m_iLightType[i] = iTypes[sortee[i].iPosition];
      m_light[i] = lights[sortee[i].iPosition];
      if(sortee[i].iPosition == iCurrent)
         iCurrentNew = i;
   }
   return iCurrentNew;
}