simple2d-3d 0.1.0__py3-none-any.whl

simple2d_3d/__init__.py

@@ -0,0 +1,5 @@
+from .setup import Init as init , CleanUp as clean_up
+from .render import Camera , Vector3 , Rect , Line , Circle , Scene , Scene2D , Raycaster2D , BreakObject2D as break_object_2d , CreatePlatform2D as create_platform_2d , CreatePlatform as create_platform , Project2D as project_2d, DrawFilledFace as draw_filled_face, Cube
+from . import colors
+__all__ = [
+    "init" , "clean_up" , "Camera" , "Vector3" , "Rect" , "Circle" , "Line" , "Scene" , "Scene2D" , "Raycaster2D" , "break_object_2d" , "create_platform_2d" , "create_platform" , "project_2d" , "draw_filled_face" , "Cube" , "colors"]

simple2d_3d/colors.py

@@ -0,0 +1,22 @@
+import sdl2
+RED = sdl2.SDL_Color(255,0,0,255)
+GREEN = sdl2.SDL_Color(0,255,0,255)
+BLUE = sdl2.SDL_Color(0,0,255,255)
+YELLOW = sdl2.SDL_Color(255,255,0,255)
+CYAN = sdl2.SDL_Color(0,255,255,255)
+WHITE = sdl2.SDL_Color(255,255,255,255)
+BLACK = sdl2.SDL_Color(0,0,0,255)
+GHOST_WHITE = sdl2.SDL_Color(248, 248, 255, 128)
+SHADOW = sdl2.SDL_Color(0, 0, 0, 150)
+TERRA_COTTA = sdl2.SDL_Color(226, 114, 91, 255)
+GOLDENROD = sdl2.SDL_Color(218, 165, 32, 255)
+OLIVE_DRAB = sdl2.SDL_Color(107, 142, 35, 255)
+CORAL = sdl2.SDL_Color(255, 127, 80, 255)
+ELECTRIC_PURPLE = sdl2.SDL_Color(191, 0, 255, 255)
+NEON_PINK = sdl2.SDL_Color(255, 20, 147, 255)
+MINT_GREEN = sdl2.SDL_Color(152, 255, 152, 255)
+TURQUOISE = sdl2.SDL_Color(64, 224, 208, 255)
+MIDNIGHT_BLUE = sdl2.SDL_Color(25, 25, 112, 255)
+SLATE_GRAY = sdl2.SDL_Color(112, 128, 144, 255)
+CHARCOAL = sdl2.SDL_Color(54, 69, 79, 255)
+EGGPLANT = sdl2.SDL_Color(49, 18, 59, 255)

simple2d_3d/render.py

@@ -0,0 +1,395 @@
+import math , sdl2 , ctypes
+from .colors import *
+class Camera:
+	def __init__(self,x,y,z,yaw,pitch):
+		self.pos = Vector3(x,y,z)
+		self.yaw = yaw
+		self.pitch = pitch
+			
+class Vector3:
+    __slots__ = ['x', 'y', 'z']
+
+    def __init__(self, x=0.0, y=0.0, z=0.0):
+        self.x = float(x)
+        self.y = float(y)
+        self.z = float(z)
+
+    def __sub__(self, other):
+        return Vector3(self.x - other.x, self.y - other.y, self.z - other.z)
+
+    def dot(self, other):
+        return self.x * other.x + self.y * other.y + self.z * other.z
+
+    def cross(self, other):
+        return Vector3(
+            self.y * other.z - self.z * other.y,
+            self.z * other.x - self.x * other.z,
+            self.x * other.y - self.y * other.x
+        )
+        
+def Project2D(x, y, z , width , height):
+    if z <= 1:	z = 1
+    ratio = height / width
+    fov_angle = 110
+    fov_rad = 1.0 / math.tan(fov_angle * 0.5 * math.pi / 180.0)
+    
+    px = x * fov_rad * ratio / z
+    py = y * fov_rad / z
+    
+    px = (px + 1) * 0.5 * width
+    py = (py + 1) * 0.5 * height
+    
+    return px, py
+
+def DrawFilledFace(renderer,idx1 , idx2 , idx3,points,color):
+    if points[idx1] and points[idx2] and points[idx3]:
+    	#color = RED
+    	v1 = sdl2.SDL_Vertex(sdl2.SDL_FPoint(points[idx1].x, points[idx1].y), color, sdl2.SDL_FPoint(0,0))
+    	#color = BLUE
+    	v2 = sdl2.SDL_Vertex(sdl2.SDL_FPoint(points[idx2].x, points[idx2].y), color, sdl2.SDL_FPoint(0,0))
+    	#color = GREEN
+    	v3 = sdl2.SDL_Vertex(sdl2.SDL_FPoint(points[idx3].x, points[idx3].y), color, sdl2.SDL_FPoint(0,0))
+    	triangle_verts = (sdl2.SDL_Vertex * 3)(v1, v2, v3)
+    	sdl2.SDL_RenderGeometry(renderer, None, triangle_verts, 3, None, 0)
+    
+class Cube:
+	def __init__(self,x,y,z,w,h,d,color):
+		self.pos = Vector3(x,y,z)
+		self.size = Vector3(w,h,d)
+		self.color = color
+		self.dist = 0
+		self.vertices = [
+			Vector3(-self.size.x , -self.size.y , -self.size.z), # 0
+			Vector3(-self.size.x , -self.size.y , self.size.z), # 1
+			Vector3(self.size.x , -self.size.y , self.size.z), # 2
+			Vector3(self.size.x, -self.size.y , -self.size.z), # 3
+			Vector3(self.size.x , self.size.y , -self.size.z), # 4
+			Vector3(-self.size.x , self.size.y , -self.size.z), # 5
+			Vector3(-self.size.x , self.size.y , self.size.z), # 6
+			Vector3(self.size.x , self.size.y , self.size.z) # 7
+			]
+		# Each line is ONE triangle (3 indices)
+		self.triangle_indices = [
+    # FRONT (Z-) - Looking from the front
+    0, 3, 4,  0, 4, 5,
+    # BACK (Z+) - Looking from the back
+    2, 1, 6,  2, 6, 7,
+    # RIGHT (X+) - Looking from the right
+    3, 2, 7,  3, 7, 4,
+    # LEFT (X-) - Looking from the left
+    1, 0, 5,  1, 5, 6,
+    # TOP (Y-) - Looking from above
+    0, 1, 2,  0, 2, 3,
+    # BOTTOM (Y+) - Looking from below
+    5, 4, 7,  5, 7, 6
+]	
+	def DrawFilled(self,renderer,camera,sin_y,cos_y,sin_p,cos_p, width , height):
+	    points = []
+	    rotated_points = []
+	    for v in self.vertices:
+	    	worldX = v.x + self.pos.x
+	    	worldY = v.y + self.pos.y
+	    	worldZ = v.z + self.pos.z
+	    	relX = worldX - camera.pos.x
+	    	relY = worldY - camera.pos.y
+	    	relZ = worldZ - camera.pos.z
+	    	rot_x = relX * cos_y + relZ * sin_y
+	    	temp_z = -relX * sin_y + relZ * cos_y
+	    	rot_y = relY * cos_p - temp_z * sin_p
+	    	rot_z = relY * sin_p + temp_z * cos_p
+	    	rotated_points.append(Vector3(rot_x,rot_y,rot_z))
+	    	
+	    	result = Project2D(rot_x,rot_y,rot_z, width , height)
+	    	px , py = 0 , 0
+	    	if result == None:	points.append(result)
+	    	else:	px , py = result
+	    	px = round(px,1)
+	    	py = round(py,1)
+	    	points.append(sdl2.SDL_FPoint(px,py))
+	    	j = 0
+	    while j < len(self.triangle_indices):
+	    	idx1 = self.triangle_indices[j]
+	    	idx2 = self.triangle_indices[j+1]
+	    	idx3 = self.triangle_indices[j+2]
+	    	v1 = rotated_points[idx1]
+	    	v2 = rotated_points[idx2]
+	    	v3 = rotated_points[idx3]
+	    	edge1 = v2 - v1
+	    	edge2 = v3 - v1
+	    	normal = edge1.cross(edge2)
+	    	if normal.dot(v1) > 0:
+	    		DrawFilledFace(renderer,idx1,idx2,idx3,points,self.color)
+	    	j += 3
+	    	
+class Scene:
+	def __init__(self,camera,near_limit,far_limit, width , height):
+		self.camera = camera
+		self.near_limit = near_limit
+		self.far_limit = far_limit
+		self.width = width
+		self.height = height
+		self.object_list = []
+		
+	def add(self,object):
+		self.object_list.append(object)
+		
+	def remove(self,object):
+		self.object_list.remove(object)
+		
+	def draw(self,renderer):
+		for object in self.object_list:
+				dx = object.pos.x - self.camera.pos.x
+				dy = object.pos.y - self.camera.pos.y
+				dz = object.pos.z - self.camera.pos.z
+				object.dist = math.sqrt(dx*dx + dy*dy + dz*dz)
+		self.object_list.sort(key=lambda c: c.dist, reverse=True)
+		rad_y = math.radians(-self.camera.yaw)
+		rad_p = math.radians(-self.camera.pitch)
+		cos_y = math.cos(rad_y)
+		sin_y = math.sin(rad_y)
+		cos_p = math.cos(rad_p)
+		sin_p = math.sin(rad_p)
+		for object in self.object_list:
+		  		if object.dist <= self.near_limit or object.dist > self.far_limit:
+		  			continue
+		  		if object.dist > self.far_limit - 10:
+		  			if object.color.a > 0:
+		  				object.color.a -= int(object.color.a - object.dist - 50)
+		  		else:	object.color.a = 255
+		  		if isinstance(object,Cube):
+		  			object.DrawFilled(renderer, self.camera,sin_y,cos_y,sin_p,cos_p,self.width,self.height)
+			
+def CreatePlatform(renderer,scene,x,y,z,w,h,d,size,space,color):
+	for i in range(w):
+			for j in range(h):
+				for k in range(d):
+					new_cube = Cube(
+					x + i*(size*2+space),
+					y + j*(size*2+space),
+					z + k*(size*2+space),
+					size , size , size,color)
+					scene.add(new_cube)				
+class Circle:
+	def __init__(self , x , y , r , color,cast_shadow=True,breakable=True):
+		self.x = x
+		self.y = y
+		self.r = r
+		self.c = color
+		self.cast_shadow = cast_shadow
+		self.breakable = breakable
+	
+	def Update(self):
+		pass
+		
+	def DrawFilled(self , renderer):
+		sdl2.SDL_SetRenderDrawColor(renderer,self.c.r , self.c.g , self.c.b , self.c.a)
+		for y in range(-self.r , self.r+1):
+			x = math.sqrt(self.r*self.r - y*y)
+			sdl2.SDL_RenderDrawLineF(renderer, self.x - x, self.y + y , self.x + x , self.y + y)
+			
+	def remove(self):
+		pass
+
+class Line:
+	def __init__(self,x1,y1,x2,y2,color,parent=None,cast_shadow=True,breakable=True):
+		self.x1 = x1
+		self.x2 = x2
+		self.y1 = y1
+		self.y2 = y2
+		self.c = color
+		self.parent = parent
+		self.cast_shadow = cast_shadow
+		self.breakable = breakable
+		
+	def Update(self):
+		pass
+		
+	def DrawFilled(self,renderer):
+		if self.parent == None:
+			sdl2.SDL_SetRenderDrawColor(renderer,self.c.r , self.c.g , self.c.b , self.c.a)
+			sdl2.SDL_RenderDrawLine(renderer,self.x1,self.y1,self.x2,self.y2)
+		else:	pass
+		
+	def remove(self):
+		pass
+		
+class Rect:
+	def __init__(self,x,y,w,h,color,scene,cast_shadow=True,breakable=True):
+		self.x = x
+		self.y = y
+		self.w = w
+		self.h = h
+		self.c = color
+		self.scene = scene
+		self.cast_shadow = cast_shadow
+		self.breakable = breakable
+		self.rect = sdl2.SDL_Rect(x,y,w,h)
+		self.line_list = []
+		self.line_list.append(Line(x,y,x+w,y,color,1,cast_shadow,breakable))
+		self.line_list.append(Line(x,y,x,y+h,color,1,cast_shadow,breakable))
+		self.line_list.append(Line(x,y+h,x+w,y+h,color,1,cast_shadow,breakable))
+		self.line_list.append(Line(x+w,y,x+w,y+h,color,1,cast_shadow,breakable))
+	
+	def Update(self):
+		if len(self.line_list)<4:	return
+		self.line_list[0].x1 , self.line_list[0].y1 , self.line_list[0].x2 , self.line_list[0].y2 , self.line_list[0].c , self.line_list[0].parent , self.line_list[0].breakable = self.x ,  self.y, self.x+self.w, self.y , self.c , 1 , self.breakable 
+		
+		self.line_list[1].x1 , self.line_list[1].y1 , self.line_list[1].x2 , self.line_list[1].y2 , self.line_list[1].c , self.line_list[1].parent , self.line_list[1].breakable = self.x , self.y, self.x , self.y+self.h , self.c , 1 , self.breakable
+		
+		self.line_list[2].x1 , self.line_list[2].y1 , self.line_list[2].x2 , self.line_list[2].y2 , self.line_list[2].c , self.line_list[2].parent , self.line_list[2].breakable = self.x , self.y+self.h , self.x+self.w , self.y+self.h , self.c  , 1 , self.breakable
+		
+		self.line_list[3].x1 , self.line_list[3].y1 , self.line_list[3].x2 , self.line_list[3].y2 , self.line_list[3].c , self.line_list[3].parent , self.line_list[3].breakable = self.x+self.w , self.y , self.x+self.w , self.y+self.h , self.c  , 1 , self.breakable
+		self.rect.x = self.x
+		self.rect.y = self.y
+		self.rect.w = self.w
+		self.rect.h = self.h
+		
+	def DrawFilled(self,renderer):
+		sdl2.SDL_SetRenderDrawColor(renderer,self.c.r , self.c.g , self.c.b , self.c.a)
+		sdl2.SDL_RenderFillRect(renderer,ctypes.byref(self.rect))
+		return self.rect
+	
+	def remove(self):
+		to_remove = list(self.line_list)
+		self.line_list.clear()
+		for line in to_remove:
+			self.scene.remove(line)
+		
+class Scene2D:
+	def __init__(self):
+		self.object_list = []
+		
+	def add(self,object):
+		if isinstance(object,Rect):
+			for line in object.line_list:
+				self.object_list.append(line)
+		self.object_list.append(object)
+		
+	def remove(self,object):
+		if object in self.object_list:
+			object.remove()
+			self.object_list.remove(object)
+			object = None
+		
+	def update(self):
+		for object in self.object_list:
+			if object in self.object_list:
+				object.Update()
+			
+	def draw(self,renderer):
+		for obj in self.object_list:
+				obj.DrawFilled(renderer)
+				
+class Raycaster2D:
+	def __init__(self,light,scene):
+		self.light = light
+		self.object_list = scene.object_list
+		self.angle = 0
+		self.rad = 0
+		self.ray_len = light.r
+		self.start_angle = 0
+		self.end_angle = 0
+		self.endX = 0
+		self.endY = 0
+		
+	def ray_object_intersect(self):
+		closest_dist = self.light.r
+		for obj in self.object_list:
+			if obj.cast_shadow:
+				if isinstance(obj,Circle):
+					ob_x , ob_y , ob_r = 0 , 0 , 0
+					ob_x , ob_y , ob_r = obj.x , obj.y , obj.r
+					dx, dy = ob_x - self.light.x, ob_y - self.light.y
+					b = -2 * (dx * math.cos(self.rad) + dy * math.sin(self.rad))
+					c = dx * dx + dy * dy - ob_r * ob_r
+					val = b * b - 4 * c
+					if val >= 0:
+		      					val_sq = math.sqrt(val)
+		      					front_dist = (-b - val_sq) /2
+		      					back_dist = (-b + val_sq) /2
+		      					dist = (back_dist if front_dist < 0 else front_dist)
+		      					if dist >= 0 and dist <= closest_dist:
+		      						closest_dist = dist
+		      					
+				if isinstance(obj,Line):
+					dx = obj.x2 - obj.x1
+					dy = obj.y2 - obj.y1
+					sin_r = math.sin(self.rad)
+					cos_r = math.cos(self.rad)
+					den = dy*cos_r-dx*sin_r
+					u = ((obj.x1-self.light.x)*sin_r-(obj.y1-self.light.y)*cos_r)/(den+0.0001)
+					t = ((obj.x1-self.light.x)*dy-(obj.y1-self.light.y)*dx)/(den+0.0001)
+					if u >= 0 and u <= 1 and t > 0 and t <= closest_dist:
+						closest_dist = t    					
+		return closest_dist
+        		
+	def raycast(self,renderer,start=0,end=360,step=1):
+	   	sdl2.SDL_SetRenderDrawColor(renderer,self.light.c.r , self.light.c.g , self.light.c.b , self.light.c.a)
+	   	self.angle = start
+	   	self.start_angle = start
+	   	self.end_angle = end
+	   	while self.angle < self.end_angle:
+	   	   	self.rad = math.radians(self.angle)
+	   	   	self.ray_len = self.light.r
+	   	   	val = self.ray_object_intersect()
+	   	   	if val != None:
+	   	   		self.ray_len = val
+	   	   		self.endX = self.light.x + self.ray_len * math.cos(self.rad)
+	   	   		self.endY = self.light.y + self.ray_len * math.sin(self.rad)
+	   	   		sdl2.SDL_RenderDrawLineF(renderer, self.light.x, self.light.y, self.endX, self.endY)
+	   	   	self.angle += step
+	   	   	
+def BreakObject2D(scene,raycaster,angle):
+	if abs(raycaster.angle+angle) > 1:
+		return
+	else:
+		to_remove = []
+		buffer = 2
+		for i in range(len(scene.object_list)):
+			if scene.object_list[i].breakable:
+				if isinstance(scene.object_list[i],Rect):
+					min_x = min(scene.object_list[i].x , scene.object_list[i].x + scene.object_list[i].w)
+					max_x = max(scene.object_list[i].x , scene.object_list[i].x + scene.object_list[i].w)
+					min_y = min(scene.object_list[i].y , scene.object_list[i].y + scene.object_list[i].h)
+					max_y = max(scene.object_list[i].y , scene.object_list[i].y + scene.object_list[i].h)
+					if (min_y - buffer <= raycaster.endY <= max_y + buffer ) and (min_x - buffer <= raycaster.endX <= max_x + buffer):
+						to_remove.append(scene.object_list[i])
+				if isinstance(scene.object_list[i],Line):
+					min_x = min(scene.object_list[i].x1,scene.object_list[i].x2)
+					max_x = max(scene.object_list[i].x1,scene.object_list[i].x2)
+					min_y = min(scene.object_list[i].y1,scene.object_list[i].y2)
+					max_y = max(scene.object_list[i].y1,scene.object_list[i].y2)
+					if (min_x - buffer <= raycaster.endX <= max_x + buffer) and (min_y - buffer <= raycaster.endY <= max_y + buffer):
+						to_remove.append(scene.object_list[i])
+				if isinstance(scene.object_list[i],Circle):
+					dx = (raycaster.endX - scene.object_list[i].x)
+					dy = (raycaster.endY - scene.object_list[i].y)
+					r = scene.object_list[i].r
+					if dx * dx + dy * dy <= r * r:
+						to_remove.append(scene.object_list[i])
+		for obj in to_remove:
+			if obj in scene.object_list:
+				scene.remove(obj)
+	
+def CreatePlatform2D(scene,map_data,w,h,space,x_offset,y_offset,cast_shadow=True):
+	row = len(map_data)
+	col = len(map_data[0])
+	current_color = None
+	for y in range(row):
+		x = 0
+		while x < col:
+			if map_data[y][x]==1:
+				start_c = x
+				current_color = RED
+				while x < col and map_data[y][x]==1:
+					x += 1
+				combined_w = (x-start_c)*w
+				new_rect = Rect(x_offset+start_c*(w+space),y_offset+y*(h+space),combined_w,h,current_color,scene,cast_shadow,False)
+				scene.add(new_rect)
+			elif map_data[y][x]==2:
+				current_color = YELLOW
+				new_rect = Rect(x_offset+x*(w+space),y_offset+y*(h+space),w,h,current_color,scene,cast_shadow,True)
+				scene.add(new_rect)
+				x += 1
+			else:
+				x += 1

simple2d_3d/setup.py

@@ -0,0 +1,23 @@
+import sdl2 , sys
+def Init(title,w,h):
+	sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
+	window = sdl2.SDL_CreateWindow(title,sdl2.SDL_WINDOWPOS_UNDEFINED,sdl2.SDL_WINDOWPOS_UNDEFINED, w , h , sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE)
+	if not window:
+		print("Error : ",sdl2.SDL_GetError())
+		sdl2.SDL_Quit()
+		sys.exit(0)
+	renderer = sdl2.SDL_CreateRenderer(window,-1,sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC)
+	if not renderer:
+		print("Error : ",sdl2.SDL_GetError())
+		sdl2.SDL_Quit()
+		sys.exit(0)
+	sdl2.SDL_SetRenderDrawBlendMode(renderer, sdl2.SDL_BLENDMODE_BLEND);
+	sdl2.SDL_GetWindowSize(window,w,h)
+	return window , renderer
+	
+def CleanUp(window , renderer):
+	if renderer:
+		sdl2.SDL_DestroyRenderer(renderer)
+	if window:
+		sdl2.SDL_DestroyWindow(window)
+	sdl2.SDL_Quit()

simple2d_3d-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: simple2d_3d
+Version: 0.1.0
+Summary: A lightweight, hardware-accelerated 2D-3D layout and engine.
+Author: ProdeeptoSundar Roy
+Project-URL: Homepage, https://github.com/rtumpa099-gif/Simple2D_3D
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pysdl2
+Dynamic: license-file
+
+# Simple2D_3D
+A lightweight, hardware-accelerated 2D-3D layout and engine.

simple2d_3d-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+simple2d_3d/__init__.py,sha256=xYdcK6tI184ZpLfC9DpbknT3MvkZeQVAQCK8p8me45I,592
+simple2d_3d/colors.py,sha256=oa4TdMzN6QbZMg7oOVAULj-NRfnr--wLE98FJaLiXME,910
+simple2d_3d/render.py,sha256=E_38TCrYBklElsp9wNvaZ0f8Ko-Y4Dz3maUmptp8EyM,13846
+simple2d_3d/setup.py,sha256=bI7PkCKa6ejHbl6vn8WmJYKz1z9tAb6-oVF6PQs1dKk,797
+simple2d_3d-0.1.0.dist-info/licenses/LICENSE,sha256=nImvLlK3J6DHaAeF9zZhAaPpex-FfCVsisr_6kpA1SE,1062
+simple2d_3d-0.1.0.dist-info/METADATA,sha256=weOxIp0mR5j5GoD6XSsDKcwHKCzASeVAb_mvdmrOT7c,572
+simple2d_3d-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+simple2d_3d-0.1.0.dist-info/top_level.txt,sha256=RSLeXzPvoYQcVyTPHZ-egVpv-QvnlURBL3eYNwGXMt0,12
+simple2d_3d-0.1.0.dist-info/RECORD,,

simple2d_3d-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simple2d_3d-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 ProdeeptoSundar Roy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple2d_3d-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simple2d_3d