Так, подчищено всякое барахло

Applications/3DTest/3DTest.lua

@@ -3,22 +3,19 @@
 
 -- package.loaded["GUI"] = nil
 -- package.loaded["doubleBuffering"] = nil
-package.loaded["vector"] = nil
-package.loaded["matrix"] = nil
-package.loaded["OpenComputersGL/Main"] = nil
-package.loaded["OpenComputersGL/Materials"] = nil
-package.loaded["OpenComputersGL/Renderer"] = nil
-package.loaded["PolyCatEngine/Main"] = nil
+-- package.loaded["vector"] = nil
+-- package.loaded["OpenComputersGL/Main"] = nil
+-- package.loaded["OpenComputersGL/Materials"] = nil
+-- package.loaded["OpenComputersGL/Renderer"] = nil
+-- package.loaded["PolyCatEngine/Main"] = nil
 
 local colorlib = require("colorlib")
-local ecs = require("ECSAPI")
 local computer = require("computer")
 local buffer = require("doubleBuffering")
 local event = require("event")
 local GUI = require("GUI")
 local windows = require("windows")
 local vector = require("vector")
-local matrix = require("matrix")
 local materials = require("OpenComputersGL/Materials")
 local renderer = require("OpenComputersGL/Renderer")
 local OCGL = require("OpenComputersGL/Main")
@@ -47,24 +44,6 @@ local blockSize = 5
 local rotationAngle = math.rad(5)
 local translationOffset = 1
 
----------------------------------------------- Lighting test ----------------------------------------------
-
--- scene:addObject(polyCatEngine.newCube(vector.newVector3(0, 0, 0), 5, materials.newSolidMaterial(0xFF4444)))
--- scene:addObject(
--- 	polyCatEngine.newMesh(
--- 		vector.newVector3(0, 0, 0),
--- 		{
--- 			vector.newVector3(0, 0, 10),
--- 			vector.newVector3(10, 0, 10),
--- 			vector.newVector3(5, 0, 0),	
--- 		},
--- 		{
--- 			OCGL.newIndexedTriangle(1, 2, 3)
--- 		},
--- 		materials.newSolidMaterial(0xFF4444)
--- 	)
--- )
-
 ---------------------------------------------- Voxel-world system ----------------------------------------------
 
 local world = {{{}}}
@@ -158,17 +137,24 @@ local function renderWorld()
 	end
 end
 
--- setBlock(1, 1, 1, 0xFFFFFF)
+-- Mode 1
 local hue, hueStep = 0, 360 / 9
-for i = -1, 1 do
-	for j = -1, 1 do
-		if not (i == 0 and j == 0) then
-			setBlock(i, 0, j, colorlib.HSBtoHEX(hue, 100, 100))
+for z = -1, 1 do
+	for x = -1, 1 do
+		if not (x == 0 and z == 0) then
+			setBlock(x, 0, z, colorlib.HSBtoHEX(hue, 100, 100))
 			hue = hue + hueStep
 		end
 	end
 end
 
+-- -- Mode 2
+-- for z = 1, 7 do
+-- 	for x = -3, 3 do
+-- 		setBlock(x, 0, z, 0xFFFFFF)
+-- 	end
+-- end
+
 ---------------------------------------------- Cat ----------------------------------------------
 
 -- scene:addObject(polyCatEngine.newPolyCatMesh(vector.newVector3(0, 5, 0), 5))
@@ -180,6 +166,18 @@ end
 -- scene.camera:rotate(math.rad(90), 0, 0)
 -- local texturedPlane = scene:addObject(polyCatEngine.newTexturedPlane(vector.newVector3(0, 0, 0), 20, 20, materials.newDebugTexture(16, 16, 40)))
 
+---------------------------------------------- Wave ----------------------------------------------
+
+-- local xCells, yCells = 4, 1
+-- local plane = polyCatEngine.newPlane(vector.newVector3(0, 0, 0), 40, 15, xCells, yCells, materials.newSolidMaterial(0xFFFFFF))
+-- plane.nextWave = function(mesh)
+-- 	for xCell = 1, xCells do
+-- 		for yCell = 1, yCells do
+			
+-- 		end
+-- 	end
+-- end
+
 ---------------------------------------------- Fractal field ----------------------------------------------
 
 -- local function createField(vector3Position, xCellCount, yCellCount, cellSize)
@@ -457,11 +455,11 @@ mainWindow.toolbar.backgroundColorSelector.onTouch = function()
 end
 
 mainWindow.toolbar:addLabel(2, elementY, elementWidth, 1, 0xEEEEEE, "RAM monitoring"):setAlignment(GUI.alignment.horizontal.center, GUI.alignment.vertical.top); elementY = elementY + 2
-mainWindow.toolbar.RAMChart = mainWindow.toolbar:addChart(2, elementY, elementWidth, mainWindow.toolbar.height - elementY - 6, 0xEEEEEE, 0xAAAAAA, 0x555555, 0x66DB80, 0.35, 0.25, "s", "%", true, {}); elementY = elementY + mainWindow.toolbar.RAMChart.height + 1
+mainWindow.toolbar.RAMChart = mainWindow.toolbar:addChart(2, elementY, elementWidth, mainWindow.toolbar.height - elementY - 3, 0xEEEEEE, 0xAAAAAA, 0x555555, 0x66DB80, 0.35, 0.25, "s", "%", true, {}); elementY = elementY + mainWindow.toolbar.RAMChart.height + 1
 mainWindow.toolbar.RAMChart.roundValues = true
-mainWindow.toolbar.RAMChart.showXAxisValues = false
+-- mainWindow.toolbar.RAMChart.showXAxisValues = false
 mainWindow.toolbar.RAMChart.counter = 1
-mainWindow.toolbar.RAMProgressBar = mainWindow.toolbar:addProgressBar(2, elementY, elementWidth, 0x66DB80, 0x2D2D2D, 0xAAAAAA, 1, true, true, "", "%")
+-- mainWindow.toolbar.RAMProgressBar = mainWindow.toolbar:addProgressBar(2, elementY, elementWidth, 0x66DB80, 0x2D2D2D, 0xAAAAAA, 1, true, true, "", "%")
 
 mainWindow.toolbar:addButton(1, mainWindow.toolbar.height - 2, mainWindow.toolbar.width, 3, 0x2D2D2D, 0xEEEEEE, 0x444444, 0xEEEEEE, "Exit").onTouch = function()
 	mainWindow:close()
@@ -475,8 +473,7 @@ end
 mainWindow.onAnyEvent = function(e)
 	if not mainWindow.toolbar.isHidden then
 		local totalMemory = computer.totalMemory()
-		mainWindow.toolbar.RAMProgressBar.value = math.ceil((totalMemory - computer.freeMemory()) / totalMemory * 100)
-		table.insert(mainWindow.toolbar.RAMChart.values, {mainWindow.toolbar.RAMChart.counter, mainWindow.toolbar.RAMProgressBar.value})
+		table.insert(mainWindow.toolbar.RAMChart.values, {mainWindow.toolbar.RAMChart.counter, math.ceil((totalMemory - computer.freeMemory()) / totalMemory * 100)})
 		mainWindow.toolbar.RAMChart.counter = mainWindow.toolbar.RAMChart.counter + 1
 		if #mainWindow.toolbar.RAMChart.values > 20 then table.remove(mainWindow.toolbar.RAMChart.values, 1) end
 

lib/OpenComputersGL/Main.lua

@@ -3,7 +3,6 @@
 
 local colorlib = require("colorlib")
 local vector = require("vector")
-local matrix = require("matrix")
 local buffer = require("doubleBuffering")
 local materials = require("OpenComputersGL/Materials")
 local renderer = require("OpenComputersGL/Renderer")

lib/OpenComputersGL/Renderer - с безфлорным алгоритмом треугольников.lua

@@ -1,355 +0,0 @@
-
--------------------------------------------------------- Libraries --------------------------------------------------------
-
-local renderer = {
-	depthBuffer = {},
-	projectionSurface = {},
-}
-
--------------------------------------------------------- Additional methods --------------------------------------------------------
-
-function renderer.clearDepthBuffer()
-	for y = 1, renderer.projectionSurface.height do
-		renderer.depthBuffer[y] = {}
-		for x = 1, renderer.projectionSurface.width do
-			renderer.depthBuffer[y][x] = math.huge
-		end
-	end
-end
-
-function renderer.setProjectionSurface(x, y, z, x2, y2, z2)
-	renderer.projectionSurface = { x = x, y = y, z = z, x2 = x2, y2 = y2, z2 = z2 }
-	renderer.projectionSurface.width = x2 - x + 1
-	renderer.projectionSurface.height = y2 - y + 1
-	renderer.projectionSurface.depth = z2 - z + 1
-	renderer.depthBuffer = {}
-	renderer.clearDepthBuffer()
-end
-
-function renderer.getDepthBufferIndexByCoordinates(x, y)
-	return (y - 1) * renderer.projectionSurface.width + x
-end
-
-function renderer.setPixelUsingDepthBuffer(x, y, pixelDepthValue, pixelColor)
-	if x >= renderer.projectionSurface.x and y >= renderer.projectionSurface.y and x <= renderer.projectionSurface.x2 and y <= renderer.projectionSurface.y2 then
-		if pixelDepthValue < renderer.depthBuffer[y][x] then
-			renderer.depthBuffer[y][x] = pixelDepthValue
-			buffer.semiPixelRawSet(buffer.getBufferIndexByCoordinates(x, math.ceil(y / 2)), pixelColor, y % 2 == 0)
-			-- buffer.set(x, y, pixelColor, 0x0, " ")
-		end
-	end
-end
-
-function renderer.isVertexInViewRange(vector3Vertex)
-	return 
-		vector3Vertex[1] >= renderer.projectionSurface.x and
-		vector3Vertex[1] <= renderer.projectionSurface.y and
-		vector3Vertex[2] >= renderer.projectionSurface.x2 and
-		vector3Vertex[2] <= renderer.projectionSurface.y2
-end
-
--------------------------------------------------------- Line rendering --------------------------------------------------------
-
-function renderer.renderLine(x1, y1, z1, x2, y2, z2, color)
-	local incycleValueFrom, incycleValueTo, outcycleValueFrom, outcycleValueTo, isReversed, incycleValueDelta, outcycleValueDelta = x1, x2, y1, y2, false, math.abs(x2 - x1), math.abs(y2 - y1)
-	if incycleValueDelta < outcycleValueDelta then
-		incycleValueFrom, incycleValueTo, outcycleValueFrom, outcycleValueTo, isReversed, incycleValueDelta, outcycleValueDelta = y1, y2, x1, x2, true, outcycleValueDelta, incycleValueDelta
-	end
-
-	if outcycleValueFrom > outcycleValueTo then
-		outcycleValueFrom, outcycleValueTo = outcycleValueTo, outcycleValueFrom
-		incycleValueFrom, incycleValueTo = incycleValueTo, incycleValueFrom
-		z1, z2 = z2, z1
-	end
-
-	local outcycleValue, outcycleValueCounter, outcycleValueTriggerIncrement = outcycleValueFrom, 1, incycleValueDelta / outcycleValueDelta
-	local outcycleValueTrigger = outcycleValueTriggerIncrement
-	local z, zStep = z1, (z2 - z1) / incycleValueDelta
-	
-	for incycleValue = incycleValueFrom, incycleValueTo, incycleValueFrom < incycleValueTo and 1 or -1 do
-		if isReversed then
-			renderer.setPixelUsingDepthBuffer(outcycleValue, incycleValue, z, color)
-		else
-			renderer.setPixelUsingDepthBuffer(incycleValue, outcycleValue, z, color)
-		end
-
-		outcycleValueCounter, z = outcycleValueCounter + 1, z + zStep
-		if outcycleValueCounter > outcycleValueTrigger then
-			outcycleValue, outcycleValueTrigger = outcycleValue + 1, outcycleValueTrigger + outcycleValueTriggerIncrement
-		end
-	end
-end
-
-function renderer.renderDot(vector3Vertex, color)
-	renderer.setPixelUsingDepthBuffer(math.floor(vector3Vertex[1]), math.floor(vector3Vertex[2]), vector3Vertex[3], color)
-end
-
--------------------------------------------------------- Triangles render --------------------------------------------------------
-
-local function fillPart(x1, x2, z1, z2, y, color)
-	if x1 > x2 then
-		x1, x2 = x2, x1
-		z1, z2 = z2, z1
-	end
-	local z, zStep = z1, (z2 - z1) / (x2 - x1)
-	for i = x1, x2 do
-		-- buffer.semiPixelSet(i, y, color)
-		renderer.setPixelUsingDepthBuffer(i, y, z, color)
-		z = z + zStep
-	end
-end
-
-function renderer.renderFilledTriangle(points, color)
-	local topID, centerID, bottomID = 1, 2, 3
-	for i = 1, 3 do
-		if points[i][2] < points[topID][2] then topID = i end
-		if points[i][2] > points[bottomID][2] then bottomID = i end
-	end
-	for i = 1, 3 do
-		if i ~= topID and i ~= bottomID then centerID = i end
-	end
-
-	-- Рассчет дельт
-	local yFromTopToCenterDelta = points[centerID][2] - points[topID][2]
-	local yFromTopToBottomDelta = points[bottomID][2] - points[topID][2]
-	local yFromCenterToBottomDelta = points[bottomID][2] - points[centerID][2]
-
-	-- Если треугольник не имеет высоты, то на кой хуй нам его вообще рисовать?
-	if yFromTopToBottomDelta == 0 then return end
-
-	local xFromTopToBottom, xFromTopToBottomIncrement = points[topID][1], (points[bottomID][1] - points[topID][1]) / (yFromTopToBottomDelta)
-	local xFromTopToBottomModifyer = xFromTopToBottomIncrement >= 0 and 1 or -1
-	xFromTopToBottomIncrement = math.abs(xFromTopToBottomIncrement)
-	local xFromTopToBottomTrigger = xFromTopToBottomIncrement
-	local xFromTopToBottomCounter = 0
-
-	local zFromTopToBottom, zFromTopToBottomStep = points[topID][3], (points[bottomID][3] - points[topID][3]) / (yFromTopToBottomDelta)
-
-
-	-- Начало отрисовки верхнего йоба-куска
-	if yFromTopToCenterDelta ~= 0 then
-		local xFromTopToCenter, xFromTopToCenterIncrement = points[topID][1], (points[centerID][1] - points[topID][1]) / (yFromTopToCenterDelta)
-		local xFromTopToCenterModifyer = xFromTopToCenterIncrement >= 0 and 1 or -1
-		xFromTopToCenterIncrement = math.abs(xFromTopToCenterIncrement)
-		local xFromTopToCenterTrigger = xFromTopToCenterIncrement
-		local xFromTopToCenterCounter = 0
-
-		local zFromTopToCenter, zFromTopToCenterStep = points[topID][3], (points[centerID][3] - points[topID][3]) / (yFromTopToCenterDelta)
-
-		for y = points[topID][2], points[centerID][2] - 1 do
-			fillPart(xFromTopToCenter, xFromTopToBottom, zFromTopToCenter, zFromTopToBottom, y, color)
-
-			while xFromTopToCenterCounter < xFromTopToCenterTrigger do
-				xFromTopToCenter = xFromTopToCenter + xFromTopToCenterModifyer
-				xFromTopToCenterCounter = xFromTopToCenterCounter + 1
-			end
-			xFromTopToCenterTrigger = xFromTopToCenterTrigger + xFromTopToCenterIncrement
-
-			while xFromTopToBottomCounter < xFromTopToBottomTrigger do
-				xFromTopToBottom = xFromTopToBottom + xFromTopToBottomModifyer
-				xFromTopToBottomCounter = xFromTopToBottomCounter + 1
-			end
-			xFromTopToBottomTrigger = xFromTopToBottomTrigger + xFromTopToBottomIncrement
-
-			zFromTopToCenter = zFromTopToCenter + zFromTopToCenterStep
-			zFromTopToBottom = zFromTopToBottom + zFromTopToBottomStep
-		end
-	end
-
-	-- Начало отрисовки нижнего йоба-куска
-	if yFromCenterToBottomDelta ~= 0 then
-		local xFromCenterToBottom, xFromCenterToBottomIncrement = points[centerID][1], (points[bottomID][1] - points[centerID][1]) / (yFromCenterToBottomDelta)
-		local xFromCenterToBottomModifyer = xFromCenterToBottomIncrement >= 0 and 1 or -1
-		xFromCenterToBottomIncrement = math.abs(xFromCenterToBottomIncrement)
-		local xFromCenterToBottomTrigger = xFromCenterToBottomIncrement
-		local xFromCenterToBottomCounter = 0
-
-		local zFromCenterToBottom, zFromCenterToBottomStep = points[centerID][3], (points[bottomID][3] - points[centerID][3]) / (yFromCenterToBottomDelta)
-	
-		for y = points[centerID][2], points[bottomID][2] do
-			fillPart(xFromCenterToBottom, xFromTopToBottom, zFromCenterToBottom, zFromTopToBottom, y, color)
-
-			while xFromCenterToBottomCounter < xFromCenterToBottomTrigger do
-				xFromCenterToBottom = xFromCenterToBottom + xFromCenterToBottomModifyer
-				xFromCenterToBottomCounter = xFromCenterToBottomCounter + 1
-			end
-			xFromCenterToBottomTrigger = xFromCenterToBottomTrigger + xFromCenterToBottomIncrement
-
-			while xFromTopToBottomCounter < xFromTopToBottomTrigger do
-				xFromTopToBottom = xFromTopToBottom + xFromTopToBottomModifyer
-				xFromTopToBottomCounter = xFromTopToBottomCounter + 1
-			end
-			xFromTopToBottomTrigger = xFromTopToBottomTrigger + xFromTopToBottomIncrement
-
-			zFromCenterToBottom = zFromCenterToBottom + zFromCenterToBottomStep
-			zFromTopToBottom = zFromTopToBottom + zFromTopToBottomStep
-		end
-	end
-end
-
-function renderer.renderTexturedTriangle(vertices, texture)
-
-end
-
-function renderer.renderTriangleObject(vector3Vertex1, vector3Vertex2, vector3Vertex3, renderMode, material)
-	if renderMode == OCGL.renderModes.material then
-		if material.type == OCGL.materialTypes.solid then
-			renderer.renderFilledTriangle(
-				{
-					OCGL.newVector3(math.floor(vector3Vertex1[1]), math.floor(vector3Vertex1[2]), vector3Vertex1[3]),
-					OCGL.newVector3(math.floor(vector3Vertex2[1]), math.floor(vector3Vertex2[2]), vector3Vertex2[3]),
-					OCGL.newVector3(math.floor(vector3Vertex3[1]), math.floor(vector3Vertex3[2]), vector3Vertex3[3])
-				},
-				material.color
-			)
-		else
-			error("Material type " .. tostring(material.type) .. " doesn't supported for rendering triangles")
-		end
-	elseif renderMode == OCGL.renderModes.wireframe then
-		renderer.renderLine(math.floor(vector3Vertex1[1]), math.floor(vector3Vertex1[2]), vector3Vertex1[3], math.floor(vector3Vertex2[1]), math.floor(vector3Vertex2[2]), vector3Vertex2[3], OCGL.colors.wireframe)
-		renderer.renderLine(math.floor(vector3Vertex2[1]), math.floor(vector3Vertex2[2]), vector3Vertex2[3], math.floor(vector3Vertex3[1]), math.floor(vector3Vertex3[2]), vector3Vertex3[3], OCGL.colors.wireframe)
-		renderer.renderLine(math.floor(vector3Vertex1[1]), math.floor(vector3Vertex1[2]), vector3Vertex1[3], math.floor(vector3Vertex3[1]), math.floor(vector3Vertex3[2]), vector3Vertex3[3], OCGL.colors.wireframe)
-	elseif renderMode == OCGL.renderModes.vertices then
-		renderer.renderDot(vector3Vertex1, OCGL.colors.wireframe)
-		renderer.renderDot(vector3Vertex2, OCGL.colors.wireframe)
-		renderer.renderDot(vector3Vertex3, OCGL.colors.wireframe)
-	else
-		error("Rendermode enum " .. tostring(renderMode) .. " doesn't supported for rendering triangles")
-	end
-end
-
--------------------------------------------------------- Mesh render --------------------------------------------------------
-
-function renderer.renderMesh(mesh, renderMode)
-	for triangleIndex = 1, #mesh.triangles do
-		-- if
-		-- 	renderer.isVertexInViewRange(mesh.verticesMatrix[mesh.triangles[triangleIndex][1]]) or
-		-- 	renderer.isVertexInViewRange(mesh.verticesMatrix[mesh.triangles[triangleIndex][2]]) or
-		-- 	renderer.isVertexInViewRange(mesh.verticesMatrix[mesh.triangles[triangleIndex][3]])
-		-- then
-			renderer.renderTriangleObject(
-				mesh.verticesMatrix[mesh.triangles[triangleIndex][1]],
-				mesh.verticesMatrix[mesh.triangles[triangleIndex][2]],
-				mesh.verticesMatrix[mesh.triangles[triangleIndex][3]],
-				renderMode,
-				mesh.triangles[triangleIndex].material or mesh.material
-			)
-		-- end
-	end
-
-	--Рендерим локальные оси
-	-- if mesh.showPivotPoint then
-	-- 	local scale = 30
-	-- 	renderer.renderLine(
-	-- 		mesh.pivotPoint.position,
-	-- 		OCGL.newVector3(mesh.pivotPoint.position[1] + mesh.pivotPoint.axis[1][1] * scale, mesh.pivotPoint.position[2] + mesh.pivotPoint.axis[1][2] * scale, mesh.pivotPoint.position[3] + mesh.pivotPoint.axis[1][3] * scale),
-	-- 		OCGL.colors.axis.x
-	-- 	)
-	-- 	renderer.renderLine(
-	-- 		mesh.pivotPoint.position,
-	-- 		OCGL.newVector3(mesh.pivotPoint.position[1] + mesh.pivotPoint.axis[2][1] * scale, mesh.pivotPoint.position[2] + mesh.pivotPoint.axis[2][2] * scale, mesh.pivotPoint.position[3] + mesh.pivotPoint.axis[2][3] * scale),
-	-- 		OCGL.colors.axis.y
-	-- 	)
-	-- 	renderer.renderLine(
-	-- 		mesh.pivotPoint.position,
-	-- 		OCGL.newVector3(mesh.pivotPoint.position[1] + mesh.pivotPoint.axis[3][1] * scale, mesh.pivotPoint.position[2] + mesh.pivotPoint.axis[3][2] * scale, mesh.pivotPoint.position[3] + mesh.pivotPoint.axis[3][3] * scale),
-	-- 		OCGL.colors.axis.z
-	-- 	)
-	-- end
-
-	return mesh
-end
-
--------------------------------------------------------- Line object render --------------------------------------------------------
-
-function renderer.renderLineObject(line, renderMode)
-	if renderMode == OCGL.renderModes.vertices then
-		renderer.renderDot(line.verticesMatrix[1], line.color)
-		renderer.renderDot(line.verticesMatrix[2], line.color)
-	else
-		renderer.renderLine(
-			math.floor(line.verticesMatrix[1][1]),
-			math.floor(line.verticesMatrix[1][2]),
-			line.verticesMatrix[1][3],
-			math.floor(line.verticesMatrix[2][1]),
-			math.floor(line.verticesMatrix[2][2]),
-			line.verticesMatrix[2][3],
-			line.color
-		)
-	-- else
-	-- 	error("Rendermode enum " .. tostring(renderMode) .. " doesn't supported for rendering lines")
-	end
-end
-
--------------------------------------------------------- FPS counter overlay render --------------------------------------------------------
-
-local function drawSegments(x, y, segments, color)
-	for i = 1, #segments do
-		if segments[i] == 1 then
-			buffer.semiPixelSquare(x, y, 3, 1, color)
-		elseif segments[i] == 2 then
-			buffer.semiPixelSquare(x + 2, y, 1, 3, color)
-		elseif segments[i] == 3 then
-			buffer.semiPixelSquare(x + 2, y + 2, 1, 3, color)
-		elseif segments[i] == 4 then
-			buffer.semiPixelSquare(x, y + 4, 3, 1, color)
-		elseif segments[i] == 5 then
-			buffer.semiPixelSquare(x, y + 2, 1, 3, color)
-		elseif segments[i] == 6 then
-			buffer.semiPixelSquare(x, y, 1, 3, color)
-		elseif segments[i] == 7 then
-			buffer.semiPixelSquare(x, y + 2, 3, 1, color)
-		else
-			error("Че за говно ты сюда напихал? Переделывай!")
-		end
-	end
-end
-
---   1
--- 6   2
---   7
--- 5   3
---   4
-
-function renderer.renderFPSCounter(x, y, renderMethod, color)
-	local numbers = {
-		["0"] = { 1, 2, 3, 4, 5, 6 },
-		["1"] = { 2, 3 },
-		["2"] = { 1, 2, 4, 5, 7 },
-		["3"] = { 1, 2, 3, 4, 7 },
-		["4"] = { 2, 3, 6, 7 },
-		["5"] = { 1, 3, 4, 6, 7 },
-		["6"] = { 1, 3, 4, 5, 6, 7 },
-		["7"] = { 1, 2, 3 },
-		["8"] = { 1, 2, 3, 4, 5, 6, 7 },
-		["9"] = { 1, 2, 3, 4, 6, 7 },
-	}
-
-	-- clock sec - 1 frame
-	-- 1 sec - x frames
-
-	local oldClock = os.clock()
-	renderMethod()
-	-- local fps = tostring(math.ceil(1 / (os.clock() - oldClock) / 10))
-
-	buffer.text(1, 1, 0xFFFFFF, "FPS: " .. os.clock() - oldClock)
-
-	-- for i = 1, #fps do
-	-- 	drawSegments(x, y, numbers[fps:sub(i, i)], color)
-	-- 	x = x + 4
-	-- end
-
-	return x - 3
-end
-
-------------------------------------------------------------------------------------------------------------------------
-
-------------------------------------------------------------------------------------------------------------------------
-
-return renderer
-
-
-
-
-
-

lib/PolyCatEngine/Main.lua

@@ -3,7 +3,6 @@
 
 local buffer = require("doubleBuffering")
 local vector = require("vector")
-local matrix = require("matrix")
 local OCGL = require("OpenComputersGL/Main")
 local renderer = require("OpenComputersGL/Renderer")
 local materials = require("OpenComputersGL/Materials")
@@ -102,6 +101,40 @@ end
 
 -------------------------------------------------------- Plane object --------------------------------------------------------
 
+function polyCatEngine.newPlane(vector3Position, width, height, segmentsWidth, segmentsHeight, material)
+	local vertices, triangles, widthCellSize, heightCellSize, vertexIndex = {}, {}, width / segmentsWidth, height / segmentsHeight, 1
+	segmentsWidth, segmentsHeight = segmentsWidth + 1, segmentsHeight + 1
+	
+	for zSegment = 1, segmentsHeight do
+		for xSegment = 1, segmentsWidth do
+			table.insert(vertices, vector.newVector3(xSegment * widthCellSize - widthCellSize, 0, zSegment * heightCellSize - heightCellSize))
+
+			if xSegment < segmentsWidth and zSegment < segmentsHeight then
+				table.insert(triangles,
+					OCGL.newIndexedTriangle(
+						vertexIndex,
+						vertexIndex + 1,
+						vertexIndex + segmentsWidth
+					)
+				)
+				table.insert(triangles,
+					OCGL.newIndexedTriangle(
+						vertexIndex + 1,
+						vertexIndex + segmentsWidth + 1,
+						vertexIndex + segmentsWidth
+					)
+				)
+			end
+
+			vertexIndex = vertexIndex + 1
+		end
+	end
+	
+	return polyCatEngine.newMesh(vector3Position, vertices, triangles, material)
+end
+
+-------------------------------------------------------- Textured plane object --------------------------------------------------------
+
 function polyCatEngine.newTexturedPlane(vector3Position, width, height, texture)
 	width, height = width / 2, height / 2
 	return polyCatEngine.newMesh(
@@ -217,7 +250,7 @@ local function cameraSetFOV(camera, FOV)
 	else
 		error("FOV can't be < 0 or > 180 degrees")
 	end
-	-- ecs.error(camera.projectionSurface)
+
 	return camera
 end
 
@@ -389,8 +422,7 @@ function polyCatEngine.meshRaycast(mesh, vector3RayStart, vector3RayEnd)
 			end 
 		end
 	end
-
-	-- ecs.error(closestTriangleIndex)
+	
 	return closestTriangleIndex, minimalDistance
 end
 

lib/PolyCatEngine/PostProcessing.lua

@@ -1,21 +0,0 @@
-
--------------------------------------------------------- Libraries --------------------------------------------------------
-
-local buffer = require("doubleBuffering")
-local postProcessing = {}
-
--------------------------------------------------------- Plane object --------------------------------------------------------
-
-function postProcessing.photofilter(color, transparency)
-	buffer.clear(color, transparency)
-end
-
-function postProcessing.fadePhotifilter(color, fromTransparency, toTransparency, step)
-	for i = fromTransparency, toTransparency, fromTransparency < toTransparency and step or -step do
-		postProcessing.photofilter(color, i)
-	end
-end
-
--------------------------------------------------------- Zalupa --------------------------------------------------------
-
-return postProcessing