Planar reflections not showing when baked reflection probes enabled

I have a reflection probe that is baked that is set to capture static environment objects like buildings/terrain etc. I also have a planar reflection probe that is following the player camera which is only set to capture the player. I am trying to have both of these displaying on a surface. When I have the baked reflection probe turned on the planar reflection will not show. Are they mutually exclusive? I am using Unity 2020.1.6f1 with HDRP.

database – Accessing hidden field Ljava/net/Socket;->impl:Ljava/net/SocketImpl; (greylist, reflection, allowed)

When im trying to open the sidebar in my app where is a user picture the user email address and also the username . And you can from that navigate to other pages but when im trying to open this sidebar it just loading and never stop loading this is what my console says:

W/DynamiteModule(  491): Local module descriptor class for providerinstaller not found.
I/DynamiteModule(  491): Considering local module providerinstaller:0 and remote module providerinstaller:0
W/ProviderInstaller(  491): Failed to load providerinstaller module: No acceptable module found. Local version is 0 and remote version is 0.
I/  491): The ClassLoaderContext is a special shared library.
I/  491): The ClassLoaderContext is a special shared library.
I/TetheringManager(  491):
I/  491): The ClassLoaderContext is a special shared library.
D/nativeloader(  491): classloader namespace configured for unbundled product apk. library_path=/product/priv-app/PrebuiltGmsCore/lib/x86:/product/priv-app/PrebuiltGmsCore/PrebuiltGmsCore.apk!/lib/x86:/product/lib:/system/product/lib
W/  491): Accessing hidden field Ldalvik/system/BaseDexClassLoader;->pathList:Ldalvik/system/DexPathList; (greylist, reflection, allowed)
W/  491): Accessing hidden field Ldalvik/system/DexPathList;->nativeLibraryDirectories:Ljava/util/List; (greylist, reflection, allowed)
W/  491): Accessing hidden field Ldalvik/system/DexPathList;->systemNativeLibraryDirectories:Ljava/util/List; (greylist, reflection, allowed)
W/  491): Accessing hidden field Ldalvik/system/DexPathList;->nativeLibraryPathElements:(Ldalvik/system/DexPathList$NativeLibraryElement; (greylist, reflection, allowed)
W/  491): Accessing hidden method Ldalvik/system/DexPathList;->makePathElements(Ljava/util/List;)(Ldalvik/system/DexPathList$NativeLibraryElement; (greylist, reflection, allowed)
V/NativeCrypto(  491): Registering com/google/android/gms/org/conscrypt/NativeCrypto's 286 native methods...
W/  491): Accessing hidden method Ljava/security/spec/ECParameterSpec;->getCurveName()Ljava/lang/String; (greylist, reflection, allowed)
I/ProviderInstaller(  491): Installed default security provider GmsCore_OpenSSL
I/  491): NativeAlloc concurrent copying GC freed 59413(4035KB) AllocSpace objects, 34(1308KB) LOS objects, 49% free, 3813KB/7626KB, paused 1.949ms total 370.344ms
W/  491): Verification of int okio.Buffer.readUtf8CodePoint() took 189.470ms (950.02 bytecodes/s) (2864B approximate peak alloc)
W/  491): Accessing hidden field Ljava/net/Socket;->impl:Ljava/net/SocketImpl; (greylist, reflection, allowed)
W/  491): Accessing hidden method Ldalvik/system/CloseGuard;->get()Ldalvik/system/CloseGuard; (greylist,core-platform-api, linking, allowed)
W/  491): Accessing hidden method Ldalvik/system/CloseGuard;->open(Ljava/lang/String;)V (greylist,core-platform-api, linking, allowed)
W/  491): Accessing hidden field Ljava/io/FileDescriptor;->descriptor:I (greylist, JNI, allowed)
W/  491): Accessing hidden method Ljava/security/spec/ECParameterSpec;->setCurveName(Ljava/lang/String;)V (greylist, reflection, allowed)
W/  491): Accessing hidden method Ldalvik/system/BlockGuard;->getThreadPolicy()Ldalvik/system/BlockGuard$Policy; (greylist,core-platform-api, linking, allowed)
W/  491): Accessing hidden method Ldalvik/system/BlockGuard$Policy;->onNetwork()V (greylist, linking, allowed)
I/  491): Background young concurrent copying GC freed 72299(3369KB) AllocSpace objects, 2(40KB) LOS objects, 48% free, 3902KB/7626KB, paused 1.247ms total 164.553ms

Entire reflection symmetric function which is near $i$ when $textrm{Im }z$ is big

Is there an analytic entire function $f:mathbb{C} rightarrow mathbb{C}$ such that

  1. $f(z)=overline{f(overline{z})},$
  2. For every $varepsilon>0$ there is a $delta >0$ such that if $textrm{Im }z > delta,$ then $|f(z)-i|<varepsilon,$
  3. $f(0)=0?$

(Note that the tangent function satisfies the three properties, but fails to be entire.) theory – Which reflection groups can be enlarged?

Based on this question I wondered the following:

Question: For each finite reflection group $Gammasubseteqmathrm O(Bbb R^d)$, what is the largest finite point group $bar Gammasubseteqmathrm O(Bbb R^d)$ that contains $Gamma$?

Some inclusions already happen among the reflection groups and their extensions:

  • For $I_2(n)$ there is no such largest group, because $$I_2(n)subset I_2(2n)subseteq I_2(4n)subsetcdotssubset I_2(2^r n)subset cdots.$$
  • In general, we have $D_dsubset B_d$.
  • In general, $A_dsubset A_d^*$, where $A_d^*$ is the extended group that results from the additional symmetries of the Coxeter-Dynkin diagram of $A_d$.
  • We have $A_3=D_3subset B_3=A_3^*$.
  • We have $D_4subset B_4subset F_4subset F_4^*$, again, $F_4^*$ is the extended group resulting from the additional symmetries of the Coxeter-Dynkin diagram.
  • We have $E_6subset E_6^*$, for the same reason as above.

I believe that $H_3, H_4,B_5,E_7,E_8$ and $B_d,dge 9$ cannot be enlarged by the same reasoning as given in this answer (because these groups are the largest reflection groups in their respective dimension and their Coxeter-Dynkin diagrams have no additional symmetries).

So we are left with the following:

Question: Can we enlarge the groups $B_d$ ($din{3,5,6,7}$), $F_4^*$, $E_6^*$ and $A_d^*$ ($dge 4$)?

Maybe the inclusion $A_dsubset A_d^*subsetcdots$ is not the right chain leading to the largest group. And I also have not touched on the reducible groups which can also be enlarged in some cases, e.g. the Coxeter-Dynkin diagram of $I_2(n)oplus I_2(n)$ has also additional symmetries. We also have inclusions like $I_1oplus B_d subset B_{d+1}$.

co.combinatorics – When are indiscrete reflection groups Coxeter groups?

A well-known theorem of Coxeter states that any discrete group $W$ which is generated by reflections across (possibly affine) hyperplanes in Euclidean space is a Coxeter group: it has a presentation with generators ${r_i, i in I}$ and relations $r_i^2=e, forall i$ and $(r_ir_j)^{m_{ij}}=e$ for some numbers $m_{ij} in {2,3,ldots} sqcup {infty}$.

I am interested in when the discreteness hypothesis can be discarded. For example, take the simplest indiscrete case: let $W$ be generated by reflections across two central hyperplanes meeting at a $pi$-irrational angle. Then $W$ is not discrete since it contains a dense set of rotations, but $W$ is still a Coxeter group with generators ${r_1,r_2}$ corresponding to the two given reflections and $m_{12}=infty$.

Note that I do not require $W$ to be generated by finitely many reflections, nor my Coxeter groups to have $|I|$ finite. However I would still be interested to know about any results particular to the finite case.


  1. Is any such group $W$ a Coxeter group? I suspect not.
  2. As a particular example: is the orthogonal group a Coxeter group? Again, probably not, but I don’t see how to prove this.
  3. Is there some nice condition, more general than discreteness, which guarantees that $W$ is a Coxeter group?

This other question also asks for reflection groups that aren’t Coxeter groups, but without focusing on discreteness. It also doesn’t insist on working in Euclidean space and does assume finite $|I|$. It got no answers.

php – Using Reflection in Calling Method from URL parameters in MVC

Currently I am working on a simple MVC framework of mine. So my Core library loads the controller and method based on the URL with the given parameters. The parameters are an array after exploding the URL. This is done by using call_user_func_array(($controller, $method), $params). To prevent user from passing incorrect parameters in URL I came up with the following solution using Reflection to check whether correct number and types of parameters are passed.


class Core {

    public function __construct(){
      $url = $this->getUrl();
      // After loading correct Model and Controller (and called method)...

      // Get params - Any values left over in url are params 
      $this->params = $url ? array_values($url) : ();
      $this->params = $this->correctURLTypes($this->params);
      $r = new ReflectionMethod($this->currentController, $this->currentMethod);
      $requiredArgs = $this->numberOfRequiredArgs(); // Only Required params not optional
      $totalArgs = $r->getNumberOfParameters(); // Total no. of params in method (required + optional)
      $givenArgs = count($this->params);
      if($givenArgs >= $requiredArgs && $givenArgs <= $totalArgs) {
        // get params at index 1, 2, 3 ... $givenArgs
        for ($i = 0; $i < $givenArgs; $i++) { 
          $param = new ReflectionParameter(array($this->currentController, $this->currentMethod), $i);
          $paramType = $param->getType();

          if($paramType == 'string') $this->params($i) = (string) $this->params($i); 
          // cast int/bool/float if expecting string

          $givenType = Utils::typeOf($this->params($i)); // static function to return type of variable
          if(!is_null($paramType) && $paramType != $givenType) { // if type specified and dont match
            die("Types dont match");
        call_user_func_array(($this->currentController, $this->currentMethod), $this->params);
      }  else {
        die("Arg count incorrect");

    public function getUrl(){
          $url = rtrim($_GET('url'), '/');
          $url = filter_var($url, FILTER_SANITIZE_URL);
          $url = explode('/', $url);
          return $url;

    public function correctURLTypes($arr) {
      foreach ($arr as $key => $value) {
        // string, int, float, bool ONLY
        if(is_numeric($value)) {
          if(ctype_digit($value)) {
            $arr($key) = (int) $value;
          } else {
            $val = $value+0;
            if(is_float($val)) {
              $arr($key) = (float) $value;
        } else {
          if(in_array($value, ('true', 'false'))) {
            if($value == 'true') 
              $arr($key) = true;
              $arr($key) = false;
          } else {
            $arr($key) = (string) $value;
      return $arr;

    public function numberOfRequiredArgs() {
      $r = new ReflectionMethod($this->currentController, $this->currentMethod);
      $required = 0;

      foreach ($r->getParameters() as $key => $val) {
        if(!$val->isDefaultValueAvailable()) $required++;

      return $required;

So a method can be called which has required type specified and may have optional parameters like:
public function show(int $id, bool $edit = true) {

I was unsure if this is a good way of doing it and if its a hack. I wanted feedback and suggestions for loading the methods and parameters in such a way.

ct.category theory – Reflection principle vs universes

In category-theoretic discussions, there is often the temptation to look at the category of all abelian groups, or of all categories, etc., which quickly leads to the usual set-theoretic problems. These are often avoided by using Grothendieck universes. In set-theoretic language, one fixes some strongly inaccessible cardinal $kappa$ — this means that $kappa$ is some uncountable cardinal such that for all $lambda<kappa$, also $2^lambda<kappa$, and for any set of $<kappa$ many sets $S_i$ of size $<kappa$, also their union is of size $<kappa$. This implies that the stage $V_kappasubset V$ of “sets of size $<kappa$” is itself a model of ZFC — by applying any of the operations on sets, like taking powersets or unions, you can never leave $V_kappa$. These sets are than termed “small”, and then the category of small abelian groups is definitely well-defined.

Historically, this approach was first used by Grothendieck; a more recent foundational text is Lurie’s work on $infty$-categories. However, their use has always created somewhat of a backlash, with some people unwilling to let axioms beyond ZFC slip into established literature. For example, I think at some point there was a long discussion whether Fermat’s Last Theorem has been proved in ZFC. More recently, I’ve seen similar arguments come up for theorems whose proofs refer to Lurie’s work. (Personally, I do not have strong feelings about this and understand the arguments either way.)

On the other hand, it has also always been the case that a closer inspection revealed that any use of universes was in fact unnecessary. For example, the Stacks Project does not use universes. Instead, (see Tag 000H say) it effectively weakens the hypothesis that $kappa$ is strongly inaccessible, to something like a strong limit cardinal of uncountable cofinality, i.e.: for all $lambda<kappa$, one has $2^lambda<kappa$, and whenever you have a countable collection of sets $S_i$ of size $<kappa$, also the union of the $S_i$ has size $<kappa$. ZFC easily proves the existence of such $kappa$, and almost every argument one might envision doing in the category of abelian groups actually also works in the category of $kappa$-small abelian groups for such $kappa$. If one does more complicated arguments, one can accordingly strengthen the initial hypothesis on $kappa$. I’ve had occasion to play this game myself, see Section 4 of for the result. From this experience, I am pretty sure that one can similar rewrite Lurie’s “Higher Topos Theory”, or any other similar category-theoretic work, in a way to remove all strongly inaccessible cardinals, replacing them by carefully chosen $kappa$ with properties such as the ones above.

In fact, there seems to be a theorem of ZFC, the reflection principle (discussed briefly in Tag 000F of the Stacks project, for example), that seems to guarantee that this is always possible. Namely, for any given finite set of formulas of set theory, there is some sufficiently large $kappa$ such that, roughly speaking, these formulas hold in $V_kappa$ if and only if they hold in $V$. This seems to say something like that that for any given finite set of formulas, one can find some $kappa$ such that $V_kappa$ behaves like a universe with respect to these formulas, but please correct me in my very naive understanding of the reflection principle! (A related fact is that ZFC proves the consistency of any given finite fragment of the axioms of ZFC.)

On the other hand, any given mathematical text only contains finitely many formulas (unless it states a “theorem schema”, which does not usually happen I believe). The question is thus, phrased slightly provocatively:

Does the reflection principle imply that it must be possible to rewrite Higher Topos Theory in a way that avoids the use of universes?

geometry – Can each edge of a Wythoffian polytope be flipped by a reflection?

A Wythoffian polytope $PsubsetBbb R^d$ is an orbit polytope of a finite reflection group, that is,

$$P:=mathrm{Orb}(Gamma,x):=mathrm{conv}{Txmid TinGamma},$$

where $Gamma$ is a finite reflection group, and $xinBbb R^d$.

Question: Is it true, that if $e$ is an edge of $P$, then there is a reflection $TinGamma$ that fixes $e$ set-wise but flips its orientation?

I am pretty sure that this is true, but I cannot find a concise argument from first principles.

reflection – Black fabric, or material, that is truely non-reflective

The usual photography suspects – materials such as Duvetyne – are meant for reflection control on-set or as backgrounds. The fabric is dark enough that you can use them in conjunction with the inverse square law to pretty much ensure that local lights (and reflections from objects on set) will be well below “exposure black” by the time (or, rather, by the distance) they make it back to your shooting subject. A very high-quality black velvet is even deader, provided that the surface fibres are properly aligned for your purposes (the sides of the fuzzy bits are merely black fabric; it’s the canyons between the fibres that does most of the actual hard work). That’s good and all, but it’s not going to get you to the dead black you want to prevent, say, dashboard reflections in windshield glass. (Well, it could work, but you’d need to brush the velvet to suit the shot, so it’s no good for video on the go or for quick shooting.) For that, you need specialty stuff.

There are two problems with specialty stuff. One is that it’s fragile, so if it’s anything that is exposed and needs to last, it’s going to need relatively frequent replacement. Every material that does what you want relies on structure as much as colour to do what it do, and that structure won’t stand up to much cleaning. The other problem is that it tends to be on the expensive side. Not “mortgage your house” expensive, just a whole lot more than most fabrics, at around $10 to $25 US per square foot (130 to 300-ish € per square metre), depending on the material. And there is stuff that is significantly more expensive – and effective – still, but it becomes entirely impractical for anything except the innards of cameras and optical instruments – all of the increased light absorbency will be killed by ordinary dust and moisture in minutes. A couple of possible solutions are Fineshut SP and VL Flocksheet, both by KoPro and available at Amazon. (The company makes black, and that’s about it. They’re the makers of Mosou Black paint as well.) Fineshut sheets are meant to line optical instruments of various sorts, with the SP version being the high-cost-but-maybe-practical end of what you’re looking for, depending on budget. Fineshut KIWAMI is the stupid-expensive stuff you really don’t want to waste money on. It’s the best stuff out there for other uses, but not for your use case. Flocksheet is more of a TelePrompTer-liner sort of thing, which is more or less what you’re looking for. Again, they’re all fragile to one degree or another, but that’s what makes them work.

Another product mentioned here is Cinefoil. Great stuff, but not at all what you’re looking for. Cinefoil’s party trick is that it’s heat-resistant while being pretty darned black. That means it can be used near hot lights. And being foil, it can easily be shaped. Needless to say, that makes it the ideal thing for impromptu light-shaping tools. It’s also great for killing reflections from light stands and so forth, mostly because there’s going to be a roll or two or three of the stuff in your gear bag or on your tape-and-gel rack in the studio. When it’s the right stuff, it can’t be beat, but it’s not the right stuff for the case you’ve laid out. It’s matte black, but it’s not nearly black enough or matte enough. You want something that looks like somebody pulled a Looney Toons portable hole out of their pocket and threw it on the surface you want to get rid of. Cinefoil isn’t that. Optical blacks are.

Well, they mostly are, at least. Light them bright enough and crank the exposure up high enough, and you’ll be able to shoot them. If you’re parked in full sun at high noon and trying to get shots of something at the back of a dimly-lit parking garage, physics doesn’t really care about your feelings… or your job. Slightly less than one percent of an awful lot is going to drown out 80 percent of next to nothing. You’d need to make sure that the light doesn’t make it to your side of the glass in that case (with shades), to the extent that you can. Black materials can only do so much.