ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include "..\Minecraft.World\FloatBuffer.h"
3#include "Frustum.h"
4
5Frustum *Frustum::frustum = new Frustum();
6
7Frustum::Frustum()
8{
9 _proj = MemoryTracker::createFloatBuffer(16);
10 _modl = MemoryTracker::createFloatBuffer(16);
11 _clip = MemoryTracker::createFloatBuffer(16);
12}
13
14Frustum::~Frustum()
15{
16 delete _proj;
17 delete _modl;
18 delete _clip;
19}
20
21
22FrustumData *Frustum::getFrustum()
23{
24 frustum->calculateFrustum();
25 return frustum;
26}
27
28
29 ///////////////////////////////// NORMALIZE PLANE \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
30 /////
31 ///// This normalizes a plane (A side) from a given frustum.
32 /////
33 ///////////////////////////////// NORMALIZE PLANE \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
34
35void Frustum::normalizePlane(float **frustum, int side)
36{
37 float magnitude = (float) sqrt(frustum[side][A] * frustum[side][A] + frustum[side][B] * frustum[side][B] + frustum[side][C] * frustum[side][C]);
38
39 // Then we divide the plane's values by it's magnitude.
40 // This makes it easier to work with.
41 frustum[side][A] /= magnitude;
42 frustum[side][B] /= magnitude;
43 frustum[side][C] /= magnitude;
44 frustum[side][D] /= magnitude;
45}
46
47void Frustum::calculateFrustum()
48{
49 _proj->clear();
50 _modl->clear();
51 _clip->clear();
52
53 // glGetFloatv() is used to extract information about our OpenGL world.
54 // Below, we pass in GL_PROJECTION_MATRIX to abstract our projection matrix.
55 // It then stores the matrix into an array of [16].
56 glGetFloat(GL_PROJECTION_MATRIX, _proj);
57
58 // By passing in GL_MODELVIEW_MATRIX, we can abstract our model view matrix.
59 // This also stores it in an array of [16].
60 glGetFloat(GL_MODELVIEW_MATRIX, _modl);
61
62 _proj->flip()->limit(16);
63 _proj->get(&proj);
64 _modl->flip()->limit(16);
65 _modl->get(&modl);
66
67 // Now that we have our modelview and projection matrix, if we combine these 2 matrices,
68 // it will give us our clipping planes. To combine 2 matrices, we multiply them.
69
70 clip[0] = modl[0] * proj[0] + modl[1] * proj[4] + modl[2] * proj[8] + modl[3] * proj[12];
71 clip[1] = modl[0] * proj[1] + modl[1] * proj[5] + modl[2] * proj[9] + modl[3] * proj[13];
72 clip[2] = modl[0] * proj[2] + modl[1] * proj[6] + modl[2] * proj[10] + modl[3] * proj[14];
73 clip[3] = modl[0] * proj[3] + modl[1] * proj[7] + modl[2] * proj[11] + modl[3] * proj[15];
74
75 clip[4] = modl[4] * proj[0] + modl[5] * proj[4] + modl[6] * proj[8] + modl[7] * proj[12];
76 clip[5] = modl[4] * proj[1] + modl[5] * proj[5] + modl[6] * proj[9] + modl[7] * proj[13];
77 clip[6] = modl[4] * proj[2] + modl[5] * proj[6] + modl[6] * proj[10] + modl[7] * proj[14];
78 clip[7] = modl[4] * proj[3] + modl[5] * proj[7] + modl[6] * proj[11] + modl[7] * proj[15];
79
80 clip[8] = modl[8] * proj[0] + modl[9] * proj[4] + modl[10] * proj[8] + modl[11] * proj[12];
81 clip[9] = modl[8] * proj[1] + modl[9] * proj[5] + modl[10] * proj[9] + modl[11] * proj[13];
82 clip[10] = modl[8] * proj[2] + modl[9] * proj[6] + modl[10] * proj[10] + modl[11] * proj[14];
83 clip[11] = modl[8] * proj[3] + modl[9] * proj[7] + modl[10] * proj[11] + modl[11] * proj[15];
84
85 clip[12] = modl[12] * proj[0] + modl[13] * proj[4] + modl[14] * proj[8] + modl[15] * proj[12];
86 clip[13] = modl[12] * proj[1] + modl[13] * proj[5] + modl[14] * proj[9] + modl[15] * proj[13];
87 clip[14] = modl[12] * proj[2] + modl[13] * proj[6] + modl[14] * proj[10] + modl[15] * proj[14];
88 clip[15] = modl[12] * proj[3] + modl[13] * proj[7] + modl[14] * proj[11] + modl[15] * proj[15];
89
90 // Now we actually want to get the sides of the frustum. To do this we take
91 // the clipping planes we received above and extract the sides from them.
92
93 // This will extract the RIGHT side of the frustum
94 m_Frustum[RIGHT][A] = clip[3] - clip[0];
95 m_Frustum[RIGHT][B] = clip[7] - clip[4];
96 m_Frustum[RIGHT][C] = clip[11] - clip[8];
97 m_Frustum[RIGHT][D] = clip[15] - clip[12];
98
99 // Now that we have a normal (A,B,C) and a distance (D) to the plane,
100 // we want to normalize that normal and distance.
101
102 // Normalize the RIGHT side
103 normalizePlane(m_Frustum, RIGHT);
104
105 // This will extract the LEFT side of the frustum
106 m_Frustum[LEFT][A] = clip[3] + clip[0];
107 m_Frustum[LEFT][B] = clip[7] + clip[4];
108 m_Frustum[LEFT][C] = clip[11] + clip[8];
109 m_Frustum[LEFT][D] = clip[15] + clip[12];
110
111 // Normalize the LEFT side
112 normalizePlane(m_Frustum, LEFT);
113
114 // This will extract the BOTTOM side of the frustum
115 m_Frustum[BOTTOM][A] = clip[3] + clip[1];
116 m_Frustum[BOTTOM][B] = clip[7] + clip[5];
117 m_Frustum[BOTTOM][C] = clip[11] + clip[9];
118 m_Frustum[BOTTOM][D] = clip[15] + clip[13];
119
120 // Normalize the BOTTOM side
121 normalizePlane(m_Frustum, BOTTOM);
122
123 // This will extract the TOP side of the frustum
124 m_Frustum[TOP][A] = clip[3] - clip[1];
125 m_Frustum[TOP][B] = clip[7] - clip[5];
126 m_Frustum[TOP][C] = clip[11] - clip[9];
127 m_Frustum[TOP][D] = clip[15] - clip[13];
128
129 // Normalize the TOP side
130 normalizePlane(m_Frustum, TOP);
131
132 // This will extract the BACK side of the frustum
133 m_Frustum[BACK][A] = clip[3] - clip[2];
134 m_Frustum[BACK][B] = clip[7] - clip[6];
135 m_Frustum[BACK][C] = clip[11] - clip[10];
136 m_Frustum[BACK][D] = clip[15] - clip[14];
137
138 // Normalize the BACK side
139 normalizePlane(m_Frustum, BACK);
140
141 // This will extract the FRONT side of the frustum
142 m_Frustum[FRONT][A] = clip[3] + clip[2];
143 m_Frustum[FRONT][B] = clip[7] + clip[6];
144 m_Frustum[FRONT][C] = clip[11] + clip[10];
145 m_Frustum[FRONT][D] = clip[15] + clip[14];
146
147 // Normalize the FRONT side
148 normalizePlane(m_Frustum, FRONT);
149}