C# Framework.RegionLightShareData类代码示例

 private void EventManager_OnSendNewWindlightProfileTargeted(RegionLightShareData wl, UUID pUUID)
 {
     IClientAPI client;
     m_scene.TryGetClient(pUUID, out client);
     SendProfileToClient(client, wl);
 }

        public void StoreRegionWindlightSettings(RegionLightShareData wl)
        {
            string sql = @"select region_id from regionwindlight where ""region_id"" = :region_id limit 1;";
            bool exists = false;
            using (NpgsqlConnection conn = new NpgsqlConnection(m_connectionString))
            {
                conn.Open();
                using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
                {
                    cmd.Parameters.Add(_Database.CreateParameter("region_id", wl.regionID.ToString() ));
                    NpgsqlDataReader dr = cmd.ExecuteReader();
                    exists = dr.Read();
                }
            }
            if (exists)
            {
                RemoveRegionWindlightSettings(wl.regionID);
            }

            // sql insert
            sql = @"INSERT INTO regionwindlight
                       (region_id
                       ,water_color_r
                       ,water_color_g
                       ,water_color_b
                       ,water_fog_density_exponent
                       ,underwater_fog_modifier
                       ,reflection_wavelet_scale_1
                       ,reflection_wavelet_scale_2
                       ,reflection_wavelet_scale_3
                       ,fresnel_scale
                       ,fresnel_offset
                       ,refract_scale_above
                       ,refract_scale_below
                       ,blur_multiplier
                       ,big_wave_direction_x
                       ,big_wave_direction_y
                       ,little_wave_direction_x
                       ,little_wave_direction_y
                       ,normal_map_texture
                       ,horizon_r
                       ,horizon_g
                       ,horizon_b
                       ,horizon_i
                       ,haze_horizon
                       ,blue_density_r
                       ,blue_density_g
                       ,blue_density_b
                       ,blue_density_i
                       ,haze_density
                       ,density_multiplier
                       ,distance_multiplier
                       ,max_altitude
                       ,sun_moon_color_r
                       ,sun_moon_color_g
                       ,sun_moon_color_b
                       ,sun_moon_color_i
                       ,sun_moon_position
                       ,ambient_r
                       ,ambient_g
                       ,ambient_b
                       ,ambient_i
                       ,east_angle
                       ,sun_glow_focus
                       ,sun_glow_size
                       ,scene_gamma
                       ,star_brightness
                       ,cloud_color_r
                       ,cloud_color_g
                       ,cloud_color_b
                       ,cloud_color_i
                       ,cloud_x
                       ,cloud_y
                       ,cloud_density
                       ,cloud_coverage
                       ,cloud_scale
                       ,cloud_detail_x
                       ,cloud_detail_y
                       ,cloud_detail_density
                       ,cloud_scroll_x
                       ,cloud_scroll_x_lock
                       ,cloud_scroll_y
                       ,cloud_scroll_y_lock
                       ,draw_classic_clouds)
                 VALUES
                       (:region_id
                       ,:water_color_r
                       ,:water_color_g
                       ,:water_color_b
                       ,:water_fog_density_exponent
                       ,:underwater_fog_modifier
                       ,:reflection_wavelet_scale_1
                       ,:reflection_wavelet_scale_2
                       ,:reflection_wavelet_scale_3
                       ,:fresnel_scale
                       ,:fresnel_offset
                       ,:refract_scale_above
                       ,:refract_scale_below
                       ,:blur_multiplier
                       ,:big_wave_direction_x
//.........这里部分代码省略.........

        private List<byte[]> compileWindlightSettings(RegionLightShareData wl)
        {
            byte[] mBlock = new Byte[249];
            int pos = 0;

            wl.waterColor.ToBytes(mBlock, 0); pos += 12;
            Utils.FloatToBytes(wl.waterFogDensityExponent).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.underwaterFogModifier).CopyTo(mBlock, pos); pos += 4;
            wl.reflectionWaveletScale.ToBytes(mBlock, pos); pos += 12;
            Utils.FloatToBytes(wl.fresnelScale).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.fresnelOffset).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.refractScaleAbove).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.refractScaleBelow).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.blurMultiplier).CopyTo(mBlock, pos); pos += 4;
            wl.bigWaveDirection.ToBytes(mBlock, pos); pos += 8;
            wl.littleWaveDirection.ToBytes(mBlock, pos); pos += 8;
            wl.normalMapTexture.ToBytes(mBlock, pos); pos += 16;
            wl.horizon.ToBytes(mBlock, pos); pos += 16;
            Utils.FloatToBytes(wl.hazeHorizon).CopyTo(mBlock, pos); pos += 4;
            wl.blueDensity.ToBytes(mBlock, pos); pos += 16;
            Utils.FloatToBytes(wl.hazeDensity).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.densityMultiplier).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.distanceMultiplier).CopyTo(mBlock, pos); pos += 4;
            wl.sunMoonColor.ToBytes(mBlock, pos); pos += 16;
            Utils.FloatToBytes(wl.sunMoonPosition).CopyTo(mBlock, pos); pos += 4;
            wl.ambient.ToBytes(mBlock, pos); pos += 16;
            Utils.FloatToBytes(wl.eastAngle).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.sunGlowFocus).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.sunGlowSize).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.sceneGamma).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.starBrightness).CopyTo(mBlock, pos); pos += 4;
            wl.cloudColor.ToBytes(mBlock, pos); pos += 16;
            wl.cloudXYDensity.ToBytes(mBlock, pos); pos += 12;
            Utils.FloatToBytes(wl.cloudCoverage).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.cloudScale).CopyTo(mBlock, pos); pos += 4;
            wl.cloudDetailXYDensity.ToBytes(mBlock, pos); pos += 12;
            Utils.FloatToBytes(wl.cloudScrollX).CopyTo(mBlock, pos); pos += 4;
            Utils.FloatToBytes(wl.cloudScrollY).CopyTo(mBlock, pos); pos += 4;
            Utils.UInt16ToBytes(wl.maxAltitude).CopyTo(mBlock, pos); pos += 2;
            mBlock[pos] = Convert.ToByte(wl.cloudScrollXLock); pos++;
            mBlock[pos] = Convert.ToByte(wl.cloudScrollYLock); pos++;
            mBlock[pos] = Convert.ToByte(wl.drawClassicClouds); pos++;
            List<byte[]> param = new List<byte[]>();
            param.Add(mBlock);
            return param;
        }

        public void SendProfileToClient(IClientAPI client, RegionLightShareData wl)
        {
            if (client == null)
                return;

            if (m_enableWindlight)
            {
                if (m_scene.RegionInfo.WindlightSettings.valid)
                {
                    List<byte[]> param = compileWindlightSettings(wl);
                    client.SendGenericMessage("Windlight", UUID.Random(), param);
                }
                else
                {
                    List<byte[]> param = new List<byte[]>();
                    client.SendGenericMessage("WindlightReset", UUID.Random(), param);
                }
            }
        }

 public void StoreWindlightProfile(RegionLightShareData wl)
 {
     RegionInfo.WindlightSettings = wl;
     SimulationDataService.StoreRegionWindlightSettings(wl);
     m_eventManager.TriggerOnSaveNewWindlightProfile();
 }

 public void SendProfileToClient(IClientAPI client, RegionLightShareData wl)
 {
     if (m_enableWindlight && m_scene.RegionInfo.WindlightSettings.valid)
     {
         List<byte[]> param = compileWindlightSettings(wl);
         client.SendGenericMessage("Windlight", param);
     }
 }

        /// <summary>
        /// Load windlight settings from region storage
        /// </summary>
        /// <param name="regionUUID">RegionID</param>
        public RegionLightShareData LoadRegionWindlightSettings(UUID regionUUID)
        {
            RegionLightShareData wl = null;

            lock (ds)
            {
                DataTable windlightTable = ds.Tables["regionwindlight"];
                DataRow windlightRow = windlightTable.Rows.Find(regionUUID.ToString());
                if (windlightRow == null)
                {
                    wl = new RegionLightShareData();
                    wl.regionID = regionUUID;
                    StoreRegionWindlightSettings(wl);
                    return wl;
                }
                wl = buildRegionWindlight(windlightRow);
                return wl;
            }
        }

        /// <summary>
        /// Build a windlight entry from the persisted data.
        /// </summary>
        /// <param name="row"></param>
        /// <returns>RegionLightShareData</returns>
        private RegionLightShareData buildRegionWindlight(DataRow row)
        {
            RegionLightShareData windlight = new RegionLightShareData();

            windlight.regionID = new UUID((string)row["region_id"]);
            windlight.waterColor.X = Convert.ToSingle(row["water_color_r"]);
            windlight.waterColor.Y = Convert.ToSingle(row["water_color_g"]);
            windlight.waterColor.Z = Convert.ToSingle(row["water_color_b"]);
            //windlight.waterColor.W = Convert.ToSingle(row["water_color_i"]); //not implemented
            windlight.waterFogDensityExponent = Convert.ToSingle(row["water_fog_density_exponent"]);
            windlight.underwaterFogModifier = Convert.ToSingle(row["underwater_fog_modifier"]);
            windlight.reflectionWaveletScale.X = Convert.ToSingle(row["reflection_wavelet_scale_1"]);
            windlight.reflectionWaveletScale.Y = Convert.ToSingle(row["reflection_wavelet_scale_2"]);
            windlight.reflectionWaveletScale.Z = Convert.ToSingle(row["reflection_wavelet_scale_3"]);
            windlight.fresnelScale = Convert.ToSingle(row["fresnel_scale"]);
            windlight.fresnelOffset = Convert.ToSingle(row["fresnel_offset"]);
            windlight.refractScaleAbove = Convert.ToSingle(row["refract_scale_above"]);
            windlight.refractScaleBelow = Convert.ToSingle(row["refract_scale_below"]);
            windlight.blurMultiplier = Convert.ToSingle(row["blur_multiplier"]);
            windlight.bigWaveDirection.X = Convert.ToSingle(row["big_wave_direction_x"]);
            windlight.bigWaveDirection.Y = Convert.ToSingle(row["big_wave_direction_y"]);
            windlight.littleWaveDirection.X = Convert.ToSingle(row["little_wave_direction_x"]);
            windlight.littleWaveDirection.Y = Convert.ToSingle(row["little_wave_direction_y"]);
            windlight.normalMapTexture = new UUID((string)row["normal_map_texture"]);
            windlight.horizon.X = Convert.ToSingle(row["horizon_r"]);
            windlight.horizon.Y = Convert.ToSingle(row["horizon_g"]);
            windlight.horizon.Z = Convert.ToSingle(row["horizon_b"]);
            windlight.horizon.W = Convert.ToSingle(row["horizon_i"]);
            windlight.hazeHorizon = Convert.ToSingle(row["haze_horizon"]);
            windlight.blueDensity.X = Convert.ToSingle(row["blue_density_r"]);
            windlight.blueDensity.Y = Convert.ToSingle(row["blue_density_g"]);
            windlight.blueDensity.Z = Convert.ToSingle(row["blue_density_b"]);
            windlight.blueDensity.W = Convert.ToSingle(row["blue_density_i"]);
            windlight.hazeDensity = Convert.ToSingle(row["haze_density"]);
            windlight.densityMultiplier = Convert.ToSingle(row["density_multiplier"]);
            windlight.distanceMultiplier = Convert.ToSingle(row["distance_multiplier"]);
            windlight.maxAltitude = Convert.ToUInt16(row["max_altitude"]);
            windlight.sunMoonColor.X = Convert.ToSingle(row["sun_moon_color_r"]);
            windlight.sunMoonColor.Y = Convert.ToSingle(row["sun_moon_color_g"]);
            windlight.sunMoonColor.Z = Convert.ToSingle(row["sun_moon_color_b"]);
            windlight.sunMoonColor.W = Convert.ToSingle(row["sun_moon_color_i"]);
            windlight.sunMoonPosition = Convert.ToSingle(row["sun_moon_position"]);
            windlight.ambient.X = Convert.ToSingle(row["ambient_r"]);
            windlight.ambient.Y = Convert.ToSingle(row["ambient_g"]);
            windlight.ambient.Z = Convert.ToSingle(row["ambient_b"]);
            windlight.ambient.W = Convert.ToSingle(row["ambient_i"]);
            windlight.eastAngle = Convert.ToSingle(row["east_angle"]);
            windlight.sunGlowFocus = Convert.ToSingle(row["sun_glow_focus"]);
            windlight.sunGlowSize = Convert.ToSingle(row["sun_glow_size"]);
            windlight.sceneGamma = Convert.ToSingle(row["scene_gamma"]);
            windlight.starBrightness = Convert.ToSingle(row["star_brightness"]);
            windlight.cloudColor.X = Convert.ToSingle(row["cloud_color_r"]);
            windlight.cloudColor.Y = Convert.ToSingle(row["cloud_color_g"]);
            windlight.cloudColor.Z = Convert.ToSingle(row["cloud_color_b"]);
            windlight.cloudColor.W = Convert.ToSingle(row["cloud_color_i"]);
            windlight.cloudXYDensity.X = Convert.ToSingle(row["cloud_x"]);
            windlight.cloudXYDensity.Y = Convert.ToSingle(row["cloud_y"]);
            windlight.cloudXYDensity.Z = Convert.ToSingle(row["cloud_density"]);
            windlight.cloudCoverage = Convert.ToSingle(row["cloud_coverage"]);
            windlight.cloudScale = Convert.ToSingle(row["cloud_scale"]);
            windlight.cloudDetailXYDensity.X = Convert.ToSingle(row["cloud_detail_x"]);
            windlight.cloudDetailXYDensity.Y = Convert.ToSingle(row["cloud_detail_y"]);
            windlight.cloudDetailXYDensity.Z = Convert.ToSingle(row["cloud_detail_density"]);
            windlight.cloudScrollX = Convert.ToSingle(row["cloud_scroll_x"]);
            windlight.cloudScrollXLock = Convert.ToBoolean(row["cloud_scroll_x_lock"]);
            windlight.cloudScrollY = Convert.ToSingle(row["cloud_scroll_y"]);
            windlight.cloudScrollYLock = Convert.ToBoolean(row["cloud_scroll_y_lock"]);
            windlight.drawClassicClouds = Convert.ToBoolean(row["draw_classic_clouds"]);

            return windlight;
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="row"></param>
 /// <param name="windlight"></param>
 private static void fillRegionWindlightRow(DataRow row, RegionLightShareData windlight)
 {
     row["region_id"] = windlight.regionID.ToString();
     row["water_color_r"] = windlight.waterColor.X;
     row["water_color_g"] = windlight.waterColor.Y;
     row["water_color_b"] = windlight.waterColor.Z;
     row["water_color_i"] = 1; //windlight.waterColor.W;  //not implemented
     row["water_fog_density_exponent"] = windlight.waterFogDensityExponent;
     row["underwater_fog_modifier"] = windlight.underwaterFogModifier;
     row["reflection_wavelet_scale_1"] = windlight.reflectionWaveletScale.X;
     row["reflection_wavelet_scale_2"] = windlight.reflectionWaveletScale.Y;
     row["reflection_wavelet_scale_3"] = windlight.reflectionWaveletScale.Z;
     row["fresnel_scale"] = windlight.fresnelScale;
     row["fresnel_offset"] = windlight.fresnelOffset;
     row["refract_scale_above"] = windlight.refractScaleAbove;
     row["refract_scale_below"] = windlight.refractScaleBelow;
     row["blur_multiplier"] = windlight.blurMultiplier;
     row["big_wave_direction_x"] = windlight.bigWaveDirection.X;
     row["big_wave_direction_y"] = windlight.bigWaveDirection.Y;
     row["little_wave_direction_x"] = windlight.littleWaveDirection.X;
     row["little_wave_direction_y"] = windlight.littleWaveDirection.Y;
     row["normal_map_texture"] = windlight.normalMapTexture.ToString();
     row["horizon_r"] = windlight.horizon.X;
     row["horizon_g"] = windlight.horizon.Y;
     row["horizon_b"] = windlight.horizon.Z;
     row["horizon_i"] = windlight.horizon.W;
     row["haze_horizon"] = windlight.hazeHorizon;
     row["blue_density_r"] = windlight.blueDensity.X;
     row["blue_density_g"] = windlight.blueDensity.Y;
     row["blue_density_b"] = windlight.blueDensity.Z;
     row["blue_density_i"] = windlight.blueDensity.W;
     row["haze_density"] = windlight.hazeDensity;
     row["density_multiplier"] = windlight.densityMultiplier;
     row["distance_multiplier"] = windlight.distanceMultiplier;
     row["max_altitude"] = windlight.maxAltitude;
     row["sun_moon_color_r"] = windlight.sunMoonColor.X;
     row["sun_moon_color_g"] = windlight.sunMoonColor.Y;
     row["sun_moon_color_b"] = windlight.sunMoonColor.Z;
     row["sun_moon_color_i"] = windlight.sunMoonColor.W;
     row["sun_moon_position"] = windlight.sunMoonPosition;
     row["ambient_r"] = windlight.ambient.X;
     row["ambient_g"] = windlight.ambient.Y;
     row["ambient_b"] = windlight.ambient.Z;
     row["ambient_i"] = windlight.ambient.W;
     row["east_angle"] = windlight.eastAngle;
     row["sun_glow_focus"] = windlight.sunGlowFocus;
     row["sun_glow_size"] = windlight.sunGlowSize;
     row["scene_gamma"] = windlight.sceneGamma;
     row["star_brightness"] = windlight.starBrightness;
     row["cloud_color_r"] = windlight.cloudColor.X;
     row["cloud_color_g"] = windlight.cloudColor.Y;
     row["cloud_color_b"] = windlight.cloudColor.Z;
     row["cloud_color_i"] = windlight.cloudColor.W;
     row["cloud_x"] = windlight.cloudXYDensity.X;
     row["cloud_y"] = windlight.cloudXYDensity.Y;
     row["cloud_density"] = windlight.cloudXYDensity.Z;
     row["cloud_coverage"] = windlight.cloudCoverage;
     row["cloud_scale"] = windlight.cloudScale;
     row["cloud_detail_x"] = windlight.cloudDetailXYDensity.X;
     row["cloud_detail_y"] = windlight.cloudDetailXYDensity.Y;
     row["cloud_detail_density"] = windlight.cloudDetailXYDensity.Z;
     row["cloud_scroll_x"] = windlight.cloudScrollX;
     row["cloud_scroll_x_lock"] = windlight.cloudScrollXLock;
     row["cloud_scroll_y"] = windlight.cloudScrollY;
     row["cloud_scroll_y_lock"] = windlight.cloudScrollYLock;
     row["draw_classic_clouds"] = windlight.drawClassicClouds;
 }

 public void RegionLightShareDataSaveFired(RegionLightShareData settings)
 {
     m_RegionLightShareDataOnSaveEventFired = true;
 }

        public void RegionLightShareDataCloneSaveTest01()
        {
            RegionLightShareData rlsd = new RegionLightShareData();
            rlsd.OnSave += RegionLightShareDataSaveFired;
            rlsd.Save();
            rlsd.OnSave -= RegionLightShareDataSaveFired;
            Assert.IsTrue(m_RegionLightShareDataOnSaveEventFired, "OnSave Event Never Fired");

            object o = rlsd.Clone();
            RegionLightShareData dupe = (RegionLightShareData) o;
            Assert.IsTrue(rlsd.sceneGamma == dupe.sceneGamma, "Memberwise Clone of RegionLightShareData failed");
        }

 public void StoreWindlightProfile(RegionLightShareData wl)
 {
     m_regInfo.WindlightSettings = wl;
     m_storageManager.DataStore.StoreRegionWindlightSettings(wl);
     m_eventManager.TriggerOnSaveNewWindlightProfile();
 }

 public void StoreRegionWindlightSettings(RegionLightShareData wl)
 {
     //This connector doesn't support the windlight module yet
 }

        /// <summary>
        /// Adds an windlight into region storage
        /// </summary>
        /// <param name="wl">RegionLightShareData</param>
        public void StoreRegionWindlightSettings(RegionLightShareData wl)
        {
            lock (ds)
            {
                DataTable windlightTable = ds.Tables["regionwindlight"];
                DataRow windlightRow = windlightTable.Rows.Find(wl.regionID.ToString());

                if (windlightRow == null)
                {
                    windlightRow = windlightTable.NewRow();
                    fillRegionWindlightRow(windlightRow, wl);
                    windlightTable.Rows.Add(windlightRow);
                }
                else
                {
                    fillRegionWindlightRow(windlightRow, wl);
                }

                Commit();
            }
        }

 public void SendProfileToClient(ScenePresence presence, RegionLightShareData wl)
 {
     IClientAPI client = presence.ControllingClient;
     if (m_enableWindlight)
     {
         if (presence.IsChildAgent == false)
         {
             List<byte[]> param = compileWindlightSettings(wl);
             client.SendGenericMessage("Windlight", param);
         }
     }
     else
     {
         //We probably don't want to spam chat with this.. probably
         //m_log.Debug("[WINDLIGHT]: Module disabled");
     }
 }