Datasets:

WalkerCH
/

stream3d

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Author: spopov@google.com (Stefan Popov)
"""An OpenGL rasterizer for PyTorch."""

import dataclasses
import importlib
import logging
from typing import Iterable, Optional, Tuple, Union

import glcontext
import moderngl
import numpy as np
import OpenGL.GL
import OpenGL.GL.NV.conservative_raster
import torch as t

from gl import egl_context

importlib.reload(glcontext)
egl_context.monkey_patch_moderngl()

InputTensor = Union[t.Tensor, np.ndarray, int, float, bool, Iterable]

log = logging.getLogger(__name__)


@dataclasses.dataclass(frozen=True)
class Uniform:
  name: str
  value: InputTensor


@dataclasses.dataclass()
class Buffer:
  binding: int
  value: InputTensor
  is_io: bool = False


@dataclasses.dataclass(frozen=True)
class Texture:
  name: str
  value: InputTensor
  bind_as_array: bool = False


@dataclasses.dataclass(frozen=True)
class RenderInput:
  # The number of points to render. The geometry shader can then convert these
  # into other geometry.
  num_points: int

  # The parameters to pass to the shaders.
  arguments: Iterable[Union[Uniform, Buffer, Texture]]

  # The vertex shader
  vertex_shader: str

  # The geometry shader
  geometry_shader: str

  # The fragment shader
  fragment_shader: str

  # The output resolution, tuple (height, width)
  output_resolution: Tuple[int, int] = (256, 256)

  # The clear color, tuple (R, G, B) or (R, G, B, A).
  clear_color: Iterable[float] = (0, 0, 0)

  # The output type (either uint8 or float32).
  output_type: t.dtype = t.uint8

  # Whether depth testing is enabled.
  depth_test_enabled: bool = True

  # Whether to use conservative rasterization
  conservative_rasterization: bool = False


class _EglRenderer:
  _context_cache: dict[int, "_EglRenderer"] = {}

  def __init__(self, gl_context: moderngl.Context, cuda_device: int):
    self._program_cache: dict[str, moderngl.Program] = {}
    self._gl_context = gl_context
    self.cuda_device = cuda_device

  @classmethod
  def get_instance(cls, cuda_device: int):
    if cuda_device not in cls._context_cache:
      # Cuda has to be initialized for the cuda_egl backend to work
      t.cuda.init()
      ctx = moderngl.create_standalone_context(backend="cuda_egl",
                                               cuda_device=cuda_device)
      cls._context_cache[cuda_device] = _EglRenderer(ctx, cuda_device)
    return cls._context_cache[cuda_device]

  def _check_gl_error(self):
    err = self._gl_context.error
    if err != "GL_NO_ERROR":
      raise ValueError(f"OpenGL error encountered: {err}")

  def _upload_uniform(self, program: moderngl.Program, parameter: Uniform):
    if parameter.name not in program:
      log.info(f"Uniform {parameter.name} not found in program")
    else:
      value = t.as_tensor(parameter.value).cpu()
      if len(value.shape) == 2:
        value = tuple(value.transpose(0, 1).reshape([-1]))
      elif len(value.shape) == 1:
        value = tuple(value)
      elif value.shape == ():
        value = value.item()
      else:
        raise ValueError("Only supports 0, 1, and 2 dim tensors.")
      program[parameter.name].value = value

  def _upload_buffer(self, parameter: Buffer) -> moderngl.Buffer:
    value = t.as_tensor(parameter.value)
    value = value.reshape([-1]).cpu().numpy()
    buffer = self._gl_context.buffer(value)
    buffer.bind_to_storage_buffer(parameter.binding)

    return buffer

  def _download_buffer(self, parameter: Buffer, buffer: moderngl.Buffer):
    value = parameter.value
    np_dtype = {t.float32: np.float32, t.int32: np.int32}[value.dtype]
    temp_buffer = np.zeros(value.shape, np_dtype)
    assert isinstance(buffer, moderngl.Buffer)
    buffer.read_into(temp_buffer)
    parameter.value = t.as_tensor(temp_buffer)

  def render(self, render_input: RenderInput):
    inp = render_input

    with self._gl_context:
      program_key = (
          f"{inp.vertex_shader}|{inp.geometry_shader}|{inp.fragment_shader}")

      if program_key not in self._program_cache:
        self._program_cache[program_key] = self._gl_context.program(
            vertex_shader=inp.vertex_shader,
            fragment_shader=inp.fragment_shader,
            geometry_shader=inp.geometry_shader)
      program = self._program_cache[program_key]

      objects_to_delete = []
      buffer_bindings: dict[int, moderngl.Buffer] = {}
      texture_location = 0
      try:
        for parameter in inp.arguments:
          if isinstance(parameter, Uniform):
            self._upload_uniform(program, parameter)
          elif isinstance(parameter, Buffer):
            buffer = self._upload_buffer(parameter)
            buffer_bindings[parameter.binding] = buffer
            objects_to_delete.append(buffer)
          elif isinstance(parameter, Texture):
            if not parameter.bind_as_array:
              raise NotImplementedError()
            if parameter.name not in program:
              log.info(f"Uniform {parameter.name} not found in program")
            else:
              val = parameter.value.cpu().numpy()
              texture = self._gl_context.texture_array(
                  val.shape[1:3] + val.shape[0:1], val.shape[3], val)
              texture.repeat_x = True
              texture.repeat_y = True
              texture.use(location=texture_location)
              program.get(parameter.name, None).value = texture_location
              texture_location += 1
              objects_to_delete.append(texture)
          else:
            raise ValueError("Unknown parameter type")
          self._check_gl_error()

        h, w = inp.output_resolution
        gl_dtype, np_dtype = {
            t.uint8: ("f1", np.uint8),
            t.float32: ("f4", np.float32)
        }[inp.output_type]

        render_buffer = self._gl_context.renderbuffer((w, h), components=4,
                                                      samples=0, dtype=gl_dtype)
        objects_to_delete.append(render_buffer)
        depth_buffer = self._gl_context.depth_renderbuffer((w, h), samples=0)
        objects_to_delete.append(depth_buffer)
        framebuffer = self._gl_context.framebuffer(render_buffer, depth_buffer)
        objects_to_delete.append(framebuffer)
        framebuffer.use()

        vertex_array = self._gl_context.vertex_array(program, ())
        objects_to_delete.append(vertex_array)
        self._gl_context.clear(*inp.clear_color)
        self._gl_context.disable(moderngl.CULL_FACE)
        if inp.depth_test_enabled:
          self._gl_context.enable(moderngl.DEPTH_TEST)
          self._gl_context.depth_func = "<="
        else:
          self._gl_context.disable(moderngl.DEPTH_TEST)

        if render_input.conservative_rasterization:
          OpenGL.GL.glEnable(
              OpenGL.GL.NV.conservative_raster.GL_CONSERVATIVE_RASTERIZATION_NV)
        else:
          OpenGL.GL.glDisable(
              OpenGL.GL.NV.conservative_raster.GL_CONSERVATIVE_RASTERIZATION_NV)

        vertex_array.render(mode=moderngl.POINTS, vertices=inp.num_points)
        self._check_gl_error()
        result = np.zeros([h, w, 4], dtype=np_dtype)
        framebuffer.read_into(result, components=4, dtype=gl_dtype)
        self._check_gl_error()

        for parameter in inp.arguments:
          if isinstance(parameter, Buffer) and parameter.is_io:
            self._download_buffer(parameter, buffer_bindings[parameter.binding])

        return t.as_tensor(result)

      finally:
        for v in objects_to_delete:
          v.release()


def get_egl_device(cuda_device: int) -> int:
  """Returns the EGL device corresponding to a CUDA device (-1 if none)."""
  pass


def gl_simple_render(render_input: RenderInput,
                     cuda_device: Optional[int] = None):
  """Renders the supplied configuration with OpenGL.
  Args:
    render_input: The render input
    cuda_device: The GPU to use, given as a CUDA device number
  Returns:
    The rendered image, output_type[height, width, 4]
  Buffer parameters with is_io set to True will be read back. This can either
  happen in the original buffer or in a new buffer. The implementation will
  update the value field in the buffer parameter in the latter case.
  There is no guarantee about the device of both the rendered image and the
  buffers that are read back.
  """
  if cuda_device is None:
    cuda_device = t.cuda.current_device()
  instance = _EglRenderer.get_instance(cuda_device)
  return instance.render(render_input)

	# Copyright 2023 Google LLC
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# https://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#
	# Author: spopov@google.com (Stefan Popov)
	"""An OpenGL rasterizer for PyTorch."""

	import dataclasses
	import importlib
	import logging
	from typing import Iterable, Optional, Tuple, Union

	import glcontext
	import moderngl
	import numpy as np
	import OpenGL.GL
	import OpenGL.GL.NV.conservative_raster
	import torch as t

	from gl import egl_context

	importlib.reload(glcontext)
	egl_context.monkey_patch_moderngl()

	InputTensor = Union[t.Tensor, np.ndarray, int, float, bool, Iterable]

	log = logging.getLogger(__name__)


	@dataclasses.dataclass(frozen=True)
	class Uniform:
	name: str
	value: InputTensor


	@dataclasses.dataclass()
	class Buffer:
	binding: int
	value: InputTensor
	is_io: bool = False


	@dataclasses.dataclass(frozen=True)
	class Texture:
	name: str
	value: InputTensor
	bind_as_array: bool = False


	@dataclasses.dataclass(frozen=True)
	class RenderInput:
	# The number of points to render. The geometry shader can then convert these
	# into other geometry.
	num_points: int

	# The parameters to pass to the shaders.
	arguments: Iterable[Union[Uniform, Buffer, Texture]]

	# The vertex shader
	vertex_shader: str

	# The geometry shader
	geometry_shader: str

	# The fragment shader
	fragment_shader: str

	# The output resolution, tuple (height, width)
	output_resolution: Tuple[int, int] = (256, 256)

	# The clear color, tuple (R, G, B) or (R, G, B, A).
	clear_color: Iterable[float] = (0, 0, 0)

	# The output type (either uint8 or float32).
	output_type: t.dtype = t.uint8

	# Whether depth testing is enabled.
	depth_test_enabled: bool = True

	# Whether to use conservative rasterization
	conservative_rasterization: bool = False


	class _EglRenderer:
	_context_cache: dict[int, "_EglRenderer"] = {}

	def __init__(self, gl_context: moderngl.Context, cuda_device: int):
	self._program_cache: dict[str, moderngl.Program] = {}
	self._gl_context = gl_context
	self.cuda_device = cuda_device

	@classmethod
	def get_instance(cls, cuda_device: int):
	if cuda_device not in cls._context_cache:
	# Cuda has to be initialized for the cuda_egl backend to work
	t.cuda.init()
	ctx = moderngl.create_standalone_context(backend="cuda_egl",
	cuda_device=cuda_device)
	cls._context_cache[cuda_device] = _EglRenderer(ctx, cuda_device)
	return cls._context_cache[cuda_device]

	def _check_gl_error(self):
	err = self._gl_context.error
	if err != "GL_NO_ERROR":
	raise ValueError(f"OpenGL error encountered: {err}")

	def _upload_uniform(self, program: moderngl.Program, parameter: Uniform):
	if parameter.name not in program:
	log.info(f"Uniform {parameter.name} not found in program")
	else:
	value = t.as_tensor(parameter.value).cpu()
	if len(value.shape) == 2:
	value = tuple(value.transpose(0, 1).reshape([-1]))
	elif len(value.shape) == 1:
	value = tuple(value)
	elif value.shape == ():
	value = value.item()
	else:
	raise ValueError("Only supports 0, 1, and 2 dim tensors.")
	program[parameter.name].value = value

	def _upload_buffer(self, parameter: Buffer) -> moderngl.Buffer:
	value = t.as_tensor(parameter.value)
	value = value.reshape([-1]).cpu().numpy()
	buffer = self._gl_context.buffer(value)
	buffer.bind_to_storage_buffer(parameter.binding)

	return buffer

	def _download_buffer(self, parameter: Buffer, buffer: moderngl.Buffer):
	value = parameter.value
	np_dtype = {t.float32: np.float32, t.int32: np.int32}[value.dtype]
	temp_buffer = np.zeros(value.shape, np_dtype)
	assert isinstance(buffer, moderngl.Buffer)
	buffer.read_into(temp_buffer)
	parameter.value = t.as_tensor(temp_buffer)

	def render(self, render_input: RenderInput):
	inp = render_input

	with self._gl_context:
	program_key = (
	f"{inp.vertex_shader}\|{inp.geometry_shader}\|{inp.fragment_shader}")

	if program_key not in self._program_cache:
	self._program_cache[program_key] = self._gl_context.program(
	vertex_shader=inp.vertex_shader,
	fragment_shader=inp.fragment_shader,
	geometry_shader=inp.geometry_shader)
	program = self._program_cache[program_key]

	objects_to_delete = []
	buffer_bindings: dict[int, moderngl.Buffer] = {}
	texture_location = 0
	try:
	for parameter in inp.arguments:
	if isinstance(parameter, Uniform):
	self._upload_uniform(program, parameter)
	elif isinstance(parameter, Buffer):
	buffer = self._upload_buffer(parameter)
	buffer_bindings[parameter.binding] = buffer
	objects_to_delete.append(buffer)
	elif isinstance(parameter, Texture):
	if not parameter.bind_as_array:
	raise NotImplementedError()
	if parameter.name not in program:
	log.info(f"Uniform {parameter.name} not found in program")
	else:
	val = parameter.value.cpu().numpy()
	texture = self._gl_context.texture_array(
	val.shape[1:3] + val.shape[0:1], val.shape[3], val)
	texture.repeat_x = True
	texture.repeat_y = True
	texture.use(location=texture_location)
	program.get(parameter.name, None).value = texture_location
	texture_location += 1
	objects_to_delete.append(texture)
	else:
	raise ValueError("Unknown parameter type")
	self._check_gl_error()

	h, w = inp.output_resolution
	gl_dtype, np_dtype = {
	t.uint8: ("f1", np.uint8),
	t.float32: ("f4", np.float32)
	}[inp.output_type]

	render_buffer = self._gl_context.renderbuffer((w, h), components=4,
	samples=0, dtype=gl_dtype)
	objects_to_delete.append(render_buffer)
	depth_buffer = self._gl_context.depth_renderbuffer((w, h), samples=0)
	objects_to_delete.append(depth_buffer)
	framebuffer = self._gl_context.framebuffer(render_buffer, depth_buffer)
	objects_to_delete.append(framebuffer)
	framebuffer.use()

	vertex_array = self._gl_context.vertex_array(program, ())
	objects_to_delete.append(vertex_array)
	self._gl_context.clear(*inp.clear_color)
	self._gl_context.disable(moderngl.CULL_FACE)
	if inp.depth_test_enabled:
	self._gl_context.enable(moderngl.DEPTH_TEST)
	self._gl_context.depth_func = "<="
	else:
	self._gl_context.disable(moderngl.DEPTH_TEST)

	if render_input.conservative_rasterization:
	OpenGL.GL.glEnable(
	OpenGL.GL.NV.conservative_raster.GL_CONSERVATIVE_RASTERIZATION_NV)
	else:
	OpenGL.GL.glDisable(
	OpenGL.GL.NV.conservative_raster.GL_CONSERVATIVE_RASTERIZATION_NV)

	vertex_array.render(mode=moderngl.POINTS, vertices=inp.num_points)
	self._check_gl_error()
	result = np.zeros([h, w, 4], dtype=np_dtype)
	framebuffer.read_into(result, components=4, dtype=gl_dtype)
	self._check_gl_error()

	for parameter in inp.arguments:
	if isinstance(parameter, Buffer) and parameter.is_io:
	self._download_buffer(parameter, buffer_bindings[parameter.binding])

	return t.as_tensor(result)

	finally:
	for v in objects_to_delete:
	v.release()


	def get_egl_device(cuda_device: int) -> int:
	"""Returns the EGL device corresponding to a CUDA device (-1 if none)."""
	pass


	def gl_simple_render(render_input: RenderInput,
	cuda_device: Optional[int] = None):
	"""Renders the supplied configuration with OpenGL.

	Args:
	render_input: The render input
	cuda_device: The GPU to use, given as a CUDA device number

	Returns:
	The rendered image, output_type[height, width, 4]

	Buffer parameters with is_io set to True will be read back. This can either
	happen in the original buffer or in a new buffer. The implementation will
	update the value field in the buffer parameter in the latter case.

	There is no guarantee about the device of both the rendered image and the
	buffers that are read back.
	"""
	if cuda_device is None:
	cuda_device = t.cuda.current_device()
	instance = _EglRenderer.get_instance(cuda_device)
	return instance.render(render_input)